Gecko [ lms.clinion.com ]

Name	Size	Permission
a2disconf	15.89 KB	-rwxr-xr-x
a2dismod	15.89 KB	-rwxr-xr-x
a2dissite	15.89 KB	-rwxr-xr-x
a2enconf	15.89 KB	-rwxr-xr-x
a2enmod	15.89 KB	-rwxr-xr-x
a2ensite	15.89 KB	-rwxr-xr-x
a2query	9.64 KB	-rwxr-xr-x
aa-remove-unknown	2.85 KB	-rwxr-xr-x
aa-status	8.41 KB	-rwxr-xr-x
accessdb	10.23 KB	-rwxr-xr-x
acpid	50.84 KB	-rwxr-xr-x
add-shell	860 B	-rwxr-xr-x
addgnupghome	3.01 KB	-rwxr-xr-x
addgroup	36.45 KB	-rwxr-xr-x
adduser	36.45 KB	-rwxr-xr-x
apache2	659.69 KB	-rwxr-xr-x
apache2ctl	7.06 KB	-rwxr-xr-x
apachectl	7.06 KB	-rwxr-xr-x
apparmor_status	8.41 KB	-rwxr-xr-x
applygnupgdefaults	2.17 KB	-rwxr-xr-x
arp	61.3 KB	-rwxr-xr-x
arpd	54.03 KB	-rwxr-xr-x
atd	26.01 KB	-rwxr-xr-x
bcache-super-show	13.99 KB	-rwxr-xr-x
biosdecode	18.87 KB	-rwxr-xr-x
bpftool	1.58 KB	-rwxr-xr-x
check_forensic	952 B	-rwxr-xr-x
chgpasswd	57.83 KB	-rwxr-xr-x
chmem	42.08 KB	-rwxr-xr-x
chpasswd	53.86 KB	-rwxr-xr-x
chroot	38.18 KB	-rwxr-xr-x
cifs.idmap	14.07 KB	-rwxr-xr-x
cifs.upcall	34.28 KB	-rwxr-xr-x
cpgr	55.96 KB	-rwxr-xr-x
cppw	55.96 KB	-rwxr-xr-x
cron	46.3 KB	-rwxr-xr-x
cryptdisks_start	1.11 KB	-rwxr-xr-x
cryptdisks_stop	1.16 KB	-rwxr-xr-x
delgroup	16.11 KB	-rwxr-xr-x
deluser	16.11 KB	-rwxr-xr-x
dmidecode	106.54 KB	-rwxr-xr-x
dnsmasq	379.6 KB	-rwxr-xr-x
dpkg-preconfigure	3.58 KB	-rwxr-xr-x
dpkg-reconfigure	4.34 KB	-rwxr-xr-x
e2freefrag	14.07 KB	-rwxr-xr-x
e4crypt	22.07 KB	-rwxr-xr-x
e4defrag	25.99 KB	-rwxr-xr-x
ephemeral-disk-warning	982 B	-rwxr-xr-x
faillock	13.99 KB	-rwxr-xr-x
fdformat	30.08 KB	-rwxr-xr-x
filefrag	14.02 KB	-rwxr-xr-x
genl	58.05 KB	-rwxr-xr-x
groupadd	61.92 KB	-rwxr-xr-x
groupdel	70.37 KB	-rwxr-xr-x
groupmems	57.87 KB	-rwxr-xr-x
groupmod	68.18 KB	-rwxr-xr-x
grpck	53.8 KB	-rwxr-xr-x
grpconv	49.68 KB	-rwxr-xr-x
grpunconv	49.68 KB	-rwxr-xr-x
grub-bios-setup	793.15 KB	-rwxr-xr-x
grub-install	1003.51 KB	-rwxr-xr-x
grub-macbless	780.84 KB	-rwxr-xr-x
grub-mkconfig	8.03 KB	-rwxr-xr-x
grub-mkdevicemap	207.62 KB	-rwxr-xr-x
grub-probe	793.09 KB	-rwxr-xr-x
grub-reboot	4.73 KB	-rwxr-xr-x
grub-set-default	3.47 KB	-rwxr-xr-x
httxt2dbm	9.99 KB	-rwxr-xr-x
hv_fcopy_daemon	1.58 KB	-rwxr-xr-x
hv_get_dhcp_info	1.39 KB	-rwxr-xr-x
hv_get_dns_info	622 B	-rwxr-xr-x
hv_kvp_daemon	1.58 KB	-rwxr-xr-x
hv_set_ifconfig	7.72 KB	-rwxr-xr-x
hv_vss_daemon	1.58 KB	-rwxr-xr-x
iconvconfig	30.25 KB	-rwxr-xr-x
init.lxc	38.5 KB	-rwxr-xr-x
init.lxc.static	1001.56 KB	-rwxr-xr-x
invoke-rc.d	15.66 KB	-rwxr-xr-x
ip6tables-apply	6.85 KB	-rwxr-xr-x
iptables-apply	6.85 KB	-rwxr-xr-x
irqbalance	62.68 KB	-rwxr-xr-x
irqbalance-ui	34.06 KB	-rwxr-xr-x
iscsi-iname	9.99 KB	-rwxr-xr-x
iscsi_discovery	5.16 KB	-rwxr-xr-x
iscsid	398.15 KB	-rwxr-xr-x
iscsistart	358.13 KB	-rwxr-xr-x
ldattach	30.08 KB	-rwxr-xr-x
locale-gen	4.3 KB	-rwxr-xr-x
logrotate	74.09 KB	-rwxr-xr-x
lsvmbus	1.58 KB	-rwxr-xr-x
luksformat	3.32 KB	-rwxr-xr-x
make-bcache	18.07 KB	-rwxr-xr-x
make-ssl-cert	3.78 KB	-rwxr-xr-x
mkinitramfs	10.89 KB	-rwxr-xr-x
mklost+found	9.99 KB	-rwxr-xr-x
mysqld	23.16 MB	-rwxr-xr-x
netdata	806.77 KB	-rwxr-xr-x
netplan	798 B	-rwxr-xr-x
newusers	82.39 KB	-rwxr-xr-x
nfnl_osf	13.99 KB	-rwxr-xr-x
nologin	5.99 KB	-rwxr-xr-x
overlayroot-chroot	2.45 KB	-rwxr-xr-x
ownership	10.13 KB	-rwxr-xr-x
pam-auth-update	19.38 KB	-rwxr-xr-x
pam_getenv	2.82 KB	-rwxr-xr-x
pam_timestamp_check	9.99 KB	-rwxr-xr-x
phpdismod	7.11 KB	-rwxr-xr-x
phpenmod	7.11 KB	-rwxr-xr-x
phpquery	6.24 KB	-rwxr-xr-x
popcon-largest-unused	543 B	-rwxr-xr-x
popularity-contest	4.92 KB	-rwxr-xr-x
pwck	49.8 KB	-rwxr-xr-x
pwconv	45.7 KB	-rwxr-xr-x
pwunconv	45.68 KB	-rwxr-xr-x
readprofile	18.11 KB	-rwxr-xr-x
remove-shell	904 B	-rwxr-xr-x
rmt	58.39 KB	-rwxr-xr-x
rmt-tar	58.39 KB	-rwxr-xr-x
rsyslogd	668.54 KB	-rwxr-xr-x
rtcwake	42.08 KB	-rwxr-xr-x
samba_kcc	11.76 KB	-rwxr-xr-x
service	9.04 KB	-rwxr-xr-x
setvesablank	14.07 KB	-rwxr-xr-x
split-logfile	2.36 KB	-rwxr-xr-x
sshd	772.41 KB	-rwxr-xr-x
tarcat	936 B	-rwxr-xr-x
tcpdump	999.6 KB	-rwxr-xr-x
tzconfig	106 B	-rwxr-xr-x
ufw	4.82 KB	-rwxr-xr-x
update-ca-certificates	5.27 KB	-rwxr-xr-x
update-grub	64 B	-rwxr-xr-x
update-grub-gfxpayload	301 B	-rwxr-xr-x
update-grub2	64 B	-rwxr-xr-x
update-info-dir	1.66 KB	-rwxr-xr-x
update-initramfs	8.04 KB	-rwxr-xr-x
update-locale	2.99 KB	-rwxr-xr-x
update-mime	8.84 KB	-rwxr-xr-x
update-passwd	30.41 KB	-rwxr-xr-x
update-pciids	2.84 KB	-rwxr-xr-x
update-rc.d	16.12 KB	-rwxr-xr-x
update-secureboot-policy	7.43 KB	-rwxr-xr-x
update-usbids	1.05 KB	-rwxr-xr-x
upgrade-from-grub-legacy	1.49 KB	-rwxr-xr-x
useradd	123.28 KB	-rwxr-xr-x
userdel	82.48 KB	-rwxr-xr-x
usermod	123.06 KB	-rwxr-xr-x
uuidd	34.16 KB	-rwxr-xr-x
validlocale	1.73 KB	-rwxr-xr-x
vcstime	9.99 KB	-rwxr-xr-x
vigr	60.18 KB	-rwxr-xr-x
vipw	60.18 KB	-rwxr-xr-x
visudo	208.8 KB	-rwxr-xr-x
vpddecode	14.27 KB	-rwxr-xr-x
waagent	1.48 KB	-rwxr-xr-x
waagent2.0	246.41 KB	-rwxr-xr-x
xfs_admin	1.35 KB	-rwxr-xr-x
xfs_bmap	638 B	-rwxr-xr-x
xfs_copy	394.31 KB	-rwxr-xr-x
xfs_db	667.63 KB	-rwxr-xr-x
xfs_estimate	10.01 KB	-rwxr-xr-x
xfs_freeze	767 B	-rwxr-xr-x
xfs_fsr	30.02 KB	-rwxr-xr-x
xfs_growfs	382.27 KB	-rwxr-xr-x
xfs_info	472 B	-rwxr-xr-x
xfs_io	130.93 KB	-rwxr-xr-x
xfs_logprint	414.27 KB	-rwxr-xr-x
xfs_mdrestore	370.28 KB	-rwxr-xr-x
xfs_metadump	747 B	-rwxr-xr-x
xfs_mkfile	1007 B	-rwxr-xr-x
xfs_ncheck	650 B	-rwxr-xr-x
xfs_quota	86.01 KB	-rwxr-xr-x
xfs_rtcp	13.99 KB	-rwxr-xr-x
zerofree	9.99 KB	-rwxr-xr-x
zic	54.14 KB	-rwxr-xr-x

Code Editor : waagent2.0

#! /usr/bin/env python3
#
# Azure Linux Agent
#
# Copyright 2015 Microsoft Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Requires Python 2.6 and Openssl 1.0+
#
# Implements parts of RFC 2131, 1541, 1497 and
# http://msdn.microsoft.com/en-us/library/cc227282%28PROT.10%29.aspx
# http://msdn.microsoft.com/en-us/library/cc227259%28PROT.13%29.aspx
#

import crypt
import random
import array
import base64
import httplib
import os
import os.path
import platform
import pwd
import re
import shutil
import socket
import SocketServer
import struct
import string
import subprocess
import sys
import tempfile
import textwrap
import threading
import time
import traceback
import xml.dom.minidom
import fcntl
import inspect
import zipfile
import json
import datetime
import xml.sax.saxutils
from distutils.version import LooseVersion

if not hasattr(subprocess,'check_output'):
    def check_output(*popenargs, **kwargs):
        r"""Backport from subprocess module from python 2.7"""
        if 'stdout' in kwargs:
            raise ValueError('stdout argument not allowed, it will be overridden.')
        process = subprocess.Popen(stdout=subprocess.PIPE, *popenargs, **kwargs)
        output, unused_err = process.communicate()
        retcode = process.poll()
        if retcode:
            cmd = kwargs.get("args")
            if cmd is None:
                cmd = popenargs[0]
            raise subprocess.CalledProcessError(retcode, cmd, output=output)
        return output

# Exception classes used by this module.
    class CalledProcessError(Exception):
        def __init__(self, returncode, cmd, output=None):
            self.returncode = returncode
            self.cmd = cmd
            self.output = output
        def __str__(self):
            return "Command '%s' returned non-zero exit status %d" % (self.cmd, self.returncode)

subprocess.check_output=check_output
    subprocess.CalledProcessError=CalledProcessError
    
GuestAgentName = "WALinuxAgent"
GuestAgentLongName = "Azure Linux Agent"
GuestAgentVersion = "WALinuxAgent-2.0.16"
ProtocolVersion = "2012-11-30" #WARNING this value is used to confirm the correct fabric protocol.

Config = None
WaAgent = None
DiskActivated = False
Openssl = "openssl"
Children = []
ExtensionChildren = []
VMM_STARTUP_SCRIPT_NAME='install'
VMM_CONFIG_FILE_NAME='linuxosconfiguration.xml'
global RulesFiles
RulesFiles = [ ]
VarLibDhcpDirectories = ["/var/lib/dhclient", "/var/lib/dhcpcd", "/var/lib/dhcp"]
EtcDhcpClientConfFiles = ["/etc/dhcp/dhclient.conf", "/etc/dhcp3/dhclient.conf"]
global LibDir
LibDir = "/var/lib/waagent"
global provisioned
provisioned=False
global provisionError
provisionError=None
HandlerStatusToAggStatus = {"installed":"Installing", "enabled":"Ready", "unintalled":"NotReady", "disabled":"NotReady"}

WaagentConf = """\
#
# Azure Linux Agent Configuration
#

Role.StateConsumer=None                 # Specified program is invoked with the argument "Ready" when we report ready status
                                        # to the endpoint server.
Role.ConfigurationConsumer=None         # Specified program is invoked with XML file argument specifying role configuration.
Role.TopologyConsumer=None              # Specified program is invoked with XML file argument specifying role topology.

Provisioning.Enabled=y                  #
Provisioning.DeleteRootPassword=y       # Password authentication for root account will be unavailable.
Provisioning.RegenerateSshHostKeyPair=y # Generate fresh host key pair.
Provisioning.SshHostKeyPairType=rsa     # Supported values are "rsa", "dsa" and "ecdsa".
Provisioning.MonitorHostName=y          # Monitor host name changes and publish changes via DHCP requests.

ResourceDisk.Format=y                   # Format if unformatted. If 'n', resource disk will not be mounted.
ResourceDisk.Filesystem=ext4            # Typically ext3 or ext4. FreeBSD images should use 'ufs2' here.
ResourceDisk.MountPoint=/mnt/resource   #
ResourceDisk.EnableSwap=n               # Create and use swapfile on resource disk.
ResourceDisk.SwapSizeMB=0               # Size of the swapfile.

LBProbeResponder=y                      # Respond to load balancer probes if requested by Azure.

Logs.Verbose=n                          # Enable verbose logs

OS.RootDeviceScsiTimeout=300            # Root device timeout in seconds.
OS.OpensslPath=None                     # If "None", the system default version is used.
"""
README_FILENAME="DATALOSS_WARNING_README.txt"
README_FILECONTENT="""\
WARNING: THIS IS A TEMPORARY DISK.

Any data stored on this drive is SUBJECT TO LOSS and THERE IS NO WAY TO RECOVER IT.

Please do not use this disk for storing any personal or application data.

For additional details to please refer to the MSDN documentation at : http://msdn.microsoft.com/en-us/library/windowsazure/jj672979.aspx
"""

############################################################
# BEGIN DISTRO CLASS DEFS
############################################################
############################################################    
#	AbstractDistro
############################################################    
class AbstractDistro(object):
    """
    AbstractDistro defines a skeleton neccesary for a concrete Distro class.

Generic methods and attributes are kept here, distribution specific attributes
    and behavior are to be placed in the concrete child named distroDistro, where
    distro is the string returned by calling python platform.linux_distribution()[0].
    So for CentOS the derived class is called 'centosDistro'.
    """

def __init__(self):
        """
        Generic Attributes go here.  These are based on 'majority rules'.
        This __init__() may be called or overriden by the child.
        """
        self.agent_service_name = os.path.basename(sys.argv[0]) 
        self.selinux=None
        self.service_cmd='/usr/sbin/service'
        self.ssh_service_restart_option='restart'
        self.ssh_service_name='ssh'
        self.ssh_config_file='/etc/ssh/sshd_config'
        self.hostname_file_path='/etc/hostname'
        self.dhcp_client_name='dhclient'
        self.requiredDeps = [ 'route', 'shutdown', 'ssh-keygen', 'useradd', 'usermod',
                              'openssl', 'sfdisk', 'fdisk', 'mkfs', 
                              'sed', 'grep', 'sudo', 'parted' ]
        self.init_script_file='/etc/init.d/waagent'
        self.agent_package_name='WALinuxAgent'
        self.fileBlackList = [ "/root/.bash_history", "/var/log/waagent.log",'/etc/resolv.conf' ]        
        self.agent_files_to_uninstall = ["/etc/waagent.conf", "/etc/logrotate.d/waagent"]
        self.grubKernelBootOptionsFile = '/etc/default/grub'
        self.grubKernelBootOptionsLine = 'GRUB_CMDLINE_LINUX_DEFAULT='
        self.getpidcmd = 'pidof'
        self.mount_dvd_cmd = 'mount'
        self.sudoers_dir_base = '/etc'
        self.waagent_conf_file = WaagentConf
        self.shadow_file_mode=0600
        self.shadow_file_path="/etc/shadow"
        self.dhcp_enabled = False
        
    def isSelinuxSystem(self):
        """
        Checks and sets self.selinux = True if SELinux is available on system.
        """
        if self.selinux == None:
            if Run("which getenforce",chk_err=False):
                self.selinux = False
            else:
                self.selinux = True
        return self.selinux
    
    def isSelinuxRunning(self):
        """
        Calls shell command 'getenforce' and returns True if 'Enforcing'.
        """
        if self.isSelinuxSystem():
            return RunGetOutput("getenforce")[1].startswith("Enforcing")
        else:
            return False
        
    def setSelinuxEnforce(self,state):
        """
        Calls shell command 'setenforce' with 'state' and returns resulting exit code.
        """
        if self.isSelinuxSystem():
            if state: s = '1'
            else: s='0'
            return Run("setenforce "+s)

def setSelinuxContext(self,path,cn):
        """
        Calls shell 'chcon' with 'path' and 'cn' context.
        Returns exit result.
        """
        if self.isSelinuxSystem():
            if not os.path.exists(path):
                Error("Path does not exist: {0}".format(path))
                return 1
            return Run('chcon ' + cn + ' ' + path)
        
    def setHostname(self,name):
        """
        Shell call to hostname.
        Returns resulting exit code.
        """
        return Run('hostname ' + name)
        
    def publishHostname(self,name):
        """
        Set the contents of the hostname file to 'name'.
        Return 1 on failure.
        """
        try:
            r=SetFileContents(self.hostname_file_path, name)
            for f in EtcDhcpClientConfFiles:
                if os.path.exists(f) and FindStringInFile(f,r'^[^#]*?send\s*host-name.*?(<hostname>|gethostname[(,)])') == None :
                    r=ReplaceFileContentsAtomic('/etc/dhcp/dhclient.conf', "send host-name \"" + name + "\";\n"
                                                + "\n".join(filter(lambda a: not a.startswith("send host-name"), GetFileContents('/etc/dhcp/dhclient.conf').split('\n'))))
        except:
            return 1
        return r
        
    def installAgentServiceScriptFiles(self):
        """
        Create the waagent support files for service installation.
        Called by registerAgentService()
        Abstract Virtual Function.  Over-ridden in concrete Distro classes.
        """
        pass

def registerAgentService(self):
        """
        Calls installAgentService to create service files.
        Shell exec service registration commands. (e.g. chkconfig --add waagent)
        Abstract Virtual Function.  Over-ridden in concrete Distro classes.
        """
        pass
    
    def uninstallAgentService(self):
        """
        Call service subsystem to remove waagent script.
        Abstract Virtual Function.  Over-ridden in concrete Distro classes.
        """
        pass

def unregisterAgentService(self):
        """
        Calls self.stopAgentService and call self.uninstallAgentService()
        """
        self.stopAgentService()
        self.uninstallAgentService()
    
    def startAgentService(self):
        """
        Service call to start the Agent service
        """
        return Run(self.service_cmd + ' ' + self.agent_service_name + ' start')
        
    def stopAgentService(self):
        """
        Service call to stop the Agent service
        """
        return Run(self.service_cmd + ' '  + self.agent_service_name + ' stop',False)
    
    def restartSshService(self):
        """
        Service call to re(start) the SSH service
        """
        sshRestartCmd = self.service_cmd + " " + self.ssh_service_name + " " + self.ssh_service_restart_option
        retcode = Run(sshRestartCmd)
        if retcode > 0:
            Error("Failed to restart SSH service with return code:" + str(retcode))
        return retcode

def sshDeployPublicKey(self,fprint,path):
        """
        Generic sshDeployPublicKey - over-ridden in some concrete Distro classes due to minor differences in openssl packages deployed
        """
        error=0
        SshPubKey = OvfEnv().OpensslToSsh(fprint)
        if SshPubKey != None:
            AppendFileContents(path, SshPubKey)
        else:
            Error("Failed: " + fprint + ".crt -> " + path)
            error = 1
        return error
    
    def checkPackageInstalled(self,p):
        """
        Query package database for prescence of an installed package.
        Abstract Virtual Function.  Over-ridden in concrete Distro classes.
        """
        pass

def checkPackageUpdateable(self,p):
        """
        Online check if updated package of walinuxagent is available.
        Abstract Virtual Function.  Over-ridden in concrete Distro classes.
        """
        pass

def deleteRootPassword(self):
        """
        Generic root password removal.
        """
        filepath="/etc/shadow"
        ReplaceFileContentsAtomic(filepath,"root:*LOCK*:14600::::::\n"
                                  + "\n".join(filter(lambda a: not a.startswith("root:"),GetFileContents(filepath).split('\n'))))
        os.chmod(filepath,self.shadow_file_mode)
        if self.isSelinuxSystem():
            self.setSelinuxContext(filepath,'system_u:object_r:shadow_t:s0')
        Log("Root password deleted.")
        return 0
    
    def changePass(self,user,password):
        Log("Change user password")
        crypt_id = Config.get("Provisioning.PasswordCryptId")
        if crypt_id is None:
            crypt_id = "6"

salt_len = Config.get("Provisioning.PasswordCryptSaltLength")
        try:
            salt_len = int(salt_len)
            if salt_len < 0 or salt_len > 10:
                salt_len = 10
        except (ValueError, TypeError):
            salt_len = 10

return self.chpasswd(user, password, crypt_id=crypt_id, 
                             salt_len=salt_len)
    
    def chpasswd(self, username, password, crypt_id=6, salt_len=10):
        passwd_hash = self.gen_password_hash(password, crypt_id, salt_len)
        cmd = "usermod -p '{0}' {1}".format(passwd_hash, username)
        ret, output = RunGetOutput(cmd, log_cmd=False)
        if ret != 0:
            return "Failed to set password for {0}: {1}".format(username, output)

def gen_password_hash(self, password, crypt_id, salt_len):
        collection = string.ascii_letters + string.digits
        salt = ''.join(random.choice(collection) for _ in range(salt_len))
        salt = "${0}${1}".format(crypt_id, salt)
        return crypt.crypt(password, salt)

def load_ata_piix(self):
        return WaAgent.TryLoadAtapiix()

def unload_ata_piix(self):
        """
        Generic function to remove ata_piix.ko.
        """
        return WaAgent.TryUnloadAtapiix()
        
    def deprovisionWarnUser(self):
        """
        Generic user warnings used at deprovision.
        """
        print("WARNING! Nameserver configuration in /etc/resolv.conf will be deleted.")

def deprovisionDeleteFiles(self):
        """
        Files to delete when VM is deprovisioned
        """
        for a in VarLibDhcpDirectories:
            Run("rm -f " + a + "/*")

# Clear LibDir, remove nameserver and root bash history
        
        for f in os.listdir(LibDir) + self.fileBlackList:
            try:
                os.remove(f)
            except:
                pass
        return 0
    
    def uninstallDeleteFiles(self):
        """
        Files to delete when agent is uninstalled.
        """
        for f in self.agent_files_to_uninstall:
            try:
                os.remove(f)
            except:
                pass
        return 0
    
    def checkDependencies(self):
        """
        Generic dependency check.
        Return 1 unless all dependencies are satisfied.
        """
        if self.checkPackageInstalled('NetworkManager'):
            Error(GuestAgentLongName + " is not compatible with network-manager.")
            return 1
        try:
            m= __import__('pyasn1')
        except ImportError:
            Error(GuestAgentLongName + " requires python-pyasn1 for your Linux distribution.")
            return 1
        for a in self.requiredDeps:
            if Run("which " + a + " > /dev/null 2>&1",chk_err=False):
                Error("Missing required dependency: " + a)
                return 1
        return 0

def packagedInstall(self,buildroot):
        """
        Called from setup.py for use by RPM.
        Copies generated files waagent.conf, under the buildroot.
        """
        if not os.path.exists(buildroot+'/etc'):
            os.mkdir(buildroot+'/etc')
        SetFileContents(buildroot+'/etc/waagent.conf', MyDistro.waagent_conf_file)
        
        if not os.path.exists(buildroot+'/etc/logrotate.d'):
            os.mkdir(buildroot+'/etc/logrotate.d')
        SetFileContents(buildroot+'/etc/logrotate.d/waagent', WaagentLogrotate)
    
        self.init_script_file=buildroot+self.init_script_file
        # this allows us to call installAgentServiceScriptFiles()
        if not os.path.exists(os.path.dirname(self.init_script_file)):
            os.mkdir(os.path.dirname(self.init_script_file))
        self.installAgentServiceScriptFiles()

def GetIpv4Address(self):
        """
        Return the ip of the 
        first active non-loopback interface.
        """
        addr=''
        iface,addr=GetFirstActiveNetworkInterfaceNonLoopback()
        return addr

def GetMacAddress(self):
        return GetMacAddress()

def GetInterfaceName(self):
        return GetFirstActiveNetworkInterfaceNonLoopback()[0]

def RestartInterface(self, iface, max_retry=3):
        for retry in range(1, max_retry + 1):
            ret = Run("ifdown " + iface + " && ifup " + iface)
            if ret == 0:
                return
            Log("Failed to restart interface: {0}, ret={1}".format(iface, ret))
            if retry < max_retry:
                Log("Retry restart interface in 5 seconds")
                time.sleep(5)

def CreateAccount(self,user, password, expiration, thumbprint):
        return CreateAccount(user, password, expiration, thumbprint)
    
    def DeleteAccount(self,user):
        return DeleteAccount(user)

def ActivateResourceDisk(self):
        """
        Format, mount, and if specified in the configuration
        set resource disk as swap.
        """
        global DiskActivated
        format = Config.get("ResourceDisk.Format")
        if format == None or format.lower().startswith("n"):
            DiskActivated = True
            return
        device = DeviceForIdePort(1)
        if device == None:
            Error("ActivateResourceDisk: Unable to detect disk topology.")
            return
        device = "/dev/" + device

mountlist = RunGetOutput("mount")[1]
        mountpoint = GetMountPoint(mountlist, device)

if(mountpoint):
            Log("ActivateResourceDisk: " + device + "1 is already mounted.")
        else:
            mountpoint = Config.get("ResourceDisk.MountPoint")
            if mountpoint == None:
                mountpoint = "/mnt/resource"
            CreateDir(mountpoint, "root", 0755)
            fs = Config.get("ResourceDisk.Filesystem")
            if fs == None:
                fs = "ext3"

partition = device + "1"

#Check partition type
            Log("Detect GPT...")
            ret = RunGetOutput("parted {0} print".format(device))
            if ret[0] == 0 and "gpt" in ret[1]:
                Log("GPT detected.")
                #GPT(Guid Partition Table) is used.
                #Get partitions.
                parts = filter(lambda x : re.match("^\s*[0-9]+", x), ret[1].split("\n"))
                #If there are more than 1 partitions, remove all partitions 
                #and create a new one using the entire disk space.
                if len(parts) > 1:
                    for i in range(1, len(parts) + 1):
                        Run("parted {0} rm {1}".format(device, i))
                    Run("parted {0} mkpart primary 0% 100%".format(device))
                    Run("mkfs." + fs + " " + partition + " -F")
            else:
                existingFS = RunGetOutput("sfdisk -q -c " + device + " 1", chk_err=False)[1].rstrip()
                if existingFS == "7" and fs != "ntfs":
                    Run("sfdisk -c " + device + " 1 83")
                    Run("mkfs." + fs + " " + partition)
            if Run("mount " + partition + " " + mountpoint, chk_err=False):
                #If mount failed, try to format the partition and mount again
                Warn("Failed to mount resource disk. Retry mounting.")            
                Run("mkfs." + fs + " " + partition + " -F")
                if Run("mount " + partition + " " + mountpoint):
                    Error("ActivateResourceDisk: Failed to mount resource disk (" + partition + ").")
                    return
            Log("Resource disk (" + partition + ") is mounted at " + mountpoint + " with fstype " + fs)

#Create README file under the root of resource disk
        SetFileContents(os.path.join(mountpoint,README_FILENAME), README_FILECONTENT)
        DiskActivated = True

#Create swap space
        swap = Config.get("ResourceDisk.EnableSwap")
        if swap == None or swap.lower().startswith("n"):
            return
        sizeKB = int(Config.get("ResourceDisk.SwapSizeMB")) * 1024
        if os.path.isfile(mountpoint + "/swapfile") and os.path.getsize(mountpoint + "/swapfile") != (sizeKB * 1024):
            os.remove(mountpoint + "/swapfile")
        if not os.path.isfile(mountpoint + "/swapfile"):
            Run("umask 0077 && dd if=/dev/zero of=" + mountpoint + "/swapfile bs=1024 count=" + str(sizeKB))
            Run("mkswap " + mountpoint + "/swapfile")
        if not Run("swapon " + mountpoint + "/swapfile"):
            Log("Enabled " + str(sizeKB) + " KB of swap at " + mountpoint + "/swapfile")
        else:
            Error("ActivateResourceDisk: Failed to activate swap at " + mountpoint + "/swapfile")

def Install(self):
        return Install()

def mediaHasFilesystem(self,dsk):
        if len(dsk) == 0 :
            return False
        if Run("LC_ALL=C fdisk -l " + dsk + " | grep Disk"):
            return False
        return True
    
    def mountDVD(self,dvd,location):
        return RunGetOutput(self.mount_dvd_cmd + ' ' + dvd + ' ' + location)

def GetHome(self):
        return GetHome()

def getDhcpClientName(self):
        return self.dhcp_client_name

def initScsiDiskTimeout(self):
        """
        Set the SCSI disk timeout when the agent starts running
        """
        self.setScsiDiskTimeout()

def setScsiDiskTimeout(self):
        """
        Iterate all SCSI disks(include hot-add) and set their timeout if their value are different from the OS.RootDeviceScsiTimeout
        """
        try:
            scsiTimeout = Config.get("OS.RootDeviceScsiTimeout")
            for diskName in [disk for disk in os.listdir("/sys/block") if disk.startswith("sd")]:
                self.setBlockDeviceTimeout(diskName, scsiTimeout)
        except:
            pass

def setBlockDeviceTimeout(self, device, timeout):
        """
        Set SCSI disk timeout by set /sys/block/sd*/device/timeout
        """
        if timeout != None and device:
            filePath = "/sys/block/" + device + "/device/timeout"
            if(GetFileContents(filePath).splitlines()[0].rstrip() != timeout):
                SetFileContents(filePath,timeout)
                Log("SetBlockDeviceTimeout: Update the device " + device + " with timeout " + timeout)

def waitForSshHostKey(self, path):
        """
        Provide a dummy waiting, since by default, ssh host key is created by waagent and the key
        should already been created.
        """
        if(os.path.isfile(path)):
            return True
        else:
            Error("Can't find host key: {0}".format(path))
            return False

def isDHCPEnabled(self):
        return self.dhcp_enabled

def stopDHCP(self):
        """
        Stop the system DHCP client so that the agent can bind on its port. If
        the distro has set dhcp_enabled to True, it will need to provide an
        implementation of this method.
        """
        raise NotImplementedError('stopDHCP method missing')

def startDHCP(self):
        """
        Start the system DHCP client. If the distro has set dhcp_enabled to
        True, it will need to provide an implementation of this method.
        """
        raise NotImplementedError('startDHCP method missing')

def translateCustomData(self, data):
        """
        Translate the custom data from a Base64 encoding. Default to no-op.
        """
        decodeCustomData = Config.get("Provisioning.DecodeCustomData")
        if decodeCustomData != None and decodeCustomData.lower().startswith("y"):
            return base64.b64decode(data)
        return data

def getConfigurationPath(self):
        return "/etc/waagent.conf"
    
    def getProcessorCores(self):
        return int(RunGetOutput("grep 'processor.*:' /proc/cpuinfo |wc -l")[1])
    
    def getTotalMemory(self):
        return int(RunGetOutput("grep MemTotal /proc/meminfo |awk '{print $2}'")[1])/1024
    
    def getInterfaceNameByMac(self, mac):
        ret, output = RunGetOutput("ifconfig -a")
        if ret != 0:
            raise Exception("Failed to get network interface info")
        output = output.replace('\n', '')
        match = re.search(r"(eth\d).*(HWaddr|ether) {0}".format(mac), 
                          output, re.IGNORECASE)
        if match is None:
            raise Exception("Failed to get ifname with mac: {0}".format(mac))
        output = match.group(0)
        eths = re.findall(r"eth\d", output)
        if eths is None or len(eths) == 0:
            raise Exception("Failed to get ifname with mac: {0}".format(mac))
        return eths[-1]

def configIpV4(self, ifName, addr, netmask=24):
        ret, output = RunGetOutput("ifconfig {0} up".format(ifName))
        if ret != 0:
            raise Exception("Failed to bring up {0}: {1}".format(ifName, 
                                                                 output))
        ret, output = RunGetOutput("ifconfig {0} {1}/{2}".format(ifName, addr,
                                                                 netmask))
        if ret != 0:
            raise Exception("Failed to config ipv4 for {0}: {1}".format(ifName, 
                                                                        output))
    def setDefaultGateway(self, gateway):
        Run("/sbin/route add default gw" + gateway, chk_err=False)

def routeAdd(self, net, mask, gateway):
        Run("/sbin/route add -net " + net + " netmask " + mask + " gw " + gateway,
            chk_err=False)

############################################################
#	GentooDistro
############################################################
gentoo_init_file = """\
#!/sbin/runscript

command=/usr/sbin/waagent
pidfile=/var/run/waagent.pid
command_args=-daemon
command_background=true
name="Azure Linux Agent"

depend()
{
	need localmount
	use logger network
	after bootmisc modules
}

"""
class gentooDistro(AbstractDistro):
    """
    Gentoo distro concrete class
    """

def __init__(self): #
        super(gentooDistro,self).__init__()
        self.service_cmd='/sbin/service'
        self.ssh_service_name='sshd'
        self.hostname_file_path='/etc/conf.d/hostname'
        self.dhcp_client_name='dhcpcd'
        self.shadow_file_mode=0640
        self.init_file=gentoo_init_file
        
    def publishHostname(self,name):
        try:
            if (os.path.isfile(self.hostname_file_path)):
                r=ReplaceFileContentsAtomic(self.hostname_file_path, "hostname=\"" + name + "\"\n"
                    + "\n".join(filter(lambda a: not a.startswith("hostname="), GetFileContents(self.hostname_file_path).split("\n"))))
        except:
            return 1
        return r
        
    def installAgentServiceScriptFiles(self):
        SetFileContents(self.init_script_file, self.init_file)
        os.chmod(self.init_script_file, 0755)

def registerAgentService(self):
        self.installAgentServiceScriptFiles()
        return Run('rc-update add ' + self.agent_service_name + ' default')
    
    def uninstallAgentService(self):
        return Run('rc-update del ' + self.agent_service_name + ' default')

def unregisterAgentService(self):
        self.stopAgentService()
        return self.uninstallAgentService()

def checkPackageInstalled(self,p):
        if Run('eix -I ^' + p + '$',chk_err=False):
            return 0
        else:
            return 1

def checkPackageUpdateable(self,p):
        if Run('eix -u ^' + p + '$',chk_err=False):
            return 0
        else:
            return 1

def RestartInterface(self, iface):
        Run("/etc/init.d/net." + iface + " restart")

############################################################    
#	SuSEDistro
############################################################    
suse_init_file = """\
#! /bin/sh
#
# Azure Linux Agent sysV init script
#
# Copyright 2013 Microsoft Corporation
# Copyright SUSE LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# /etc/init.d/waagent
#
#  and symbolic link
#
# /usr/sbin/rcwaagent
#
# System startup script for the waagent
#
### BEGIN INIT INFO
# Provides: AzureLinuxAgent
# Required-Start: $network sshd
# Required-Stop: $network sshd
# Default-Start: 3 5
# Default-Stop: 0 1 2 6
# Description: Start the AzureLinuxAgent
### END INIT INFO

PYTHON=/usr/bin/python
WAZD_BIN=/usr/sbin/waagent
WAZD_CONF=/etc/waagent.conf
WAZD_PIDFILE=/var/run/waagent.pid

test -x "$WAZD_BIN" || { echo "$WAZD_BIN not installed"; exit 5; }
test -e "$WAZD_CONF" || { echo "$WAZD_CONF not found"; exit 6; }

. /etc/rc.status

# First reset status of this service
rc_reset

# Return values acc. to LSB for all commands but status:
# 0 - success
# 1 - misc error
# 2 - invalid or excess args
# 3 - unimplemented feature (e.g. reload)
# 4 - insufficient privilege
# 5 - program not installed
# 6 - program not configured
#
# Note that starting an already running service, stopping
# or restarting a not-running service as well as the restart
# with force-reload (in case signalling is not supported) are
# considered a success.

case "$1" in
    start)
        echo -n "Starting AzureLinuxAgent"
        ## Start daemon with startproc(8). If this fails
        ## the echo return value is set appropriate.
        startproc -f ${PYTHON} ${WAZD_BIN} -daemon
        rc_status -v
        ;;
    stop)
        echo -n "Shutting down AzureLinuxAgent"
        ## Stop daemon with killproc(8) and if this fails
        ## set echo the echo return value.
        killproc -p ${WAZD_PIDFILE} ${PYTHON} ${WAZD_BIN}
        rc_status -v
        ;;
    try-restart)
        ## Stop the service and if this succeeds (i.e. the
        ## service was running before), start it again.
        $0 status >/dev/null && $0 restart
        rc_status
        ;;
    restart)
        ## Stop the service and regardless of whether it was
        ## running or not, start it again.
        $0 stop
        sleep 1
        $0 start
        rc_status
        ;;
    force-reload|reload)
        rc_status
        ;;
    status)
        echo -n "Checking for service AzureLinuxAgent "
        ## Check status with checkproc(8), if process is running
        ## checkproc will return with exit status 0.

checkproc -p ${WAZD_PIDFILE} ${PYTHON} ${WAZD_BIN}
        rc_status -v
        ;;
    probe)
        ;;
    *)
        echo "Usage: $0 {start|stop|status|try-restart|restart|force-reload|reload}"
        exit 1
        ;;
esac
rc_exit
"""
class SuSEDistro(AbstractDistro):
    """
    SuSE Distro concrete class
    Put SuSE specific behavior here...
    """
    def __init__(self):
        super(SuSEDistro,self).__init__()
        self.service_cmd='/sbin/service'
        self.ssh_service_name='sshd'
        self.kernel_boot_options_file='/boot/grub/menu.lst'
        self.hostname_file_path='/etc/HOSTNAME'
        self.requiredDeps += [ "/sbin/insserv" ]
        self.init_file=suse_init_file
        self.dhcp_client_name='dhcpcd'
        if ((DistInfo(fullname=1)[0] == 'SUSE Linux Enterprise Server' and DistInfo()[1] >= '12') or \
            (DistInfo(fullname=1)[0] == 'openSUSE'                     and DistInfo()[1] >= '13.2')):
            self.dhcp_client_name='wickedd-dhcp4'
        self.grubKernelBootOptionsFile = '/boot/grub/menu.lst'
        self.grubKernelBootOptionsLine = 'kernel'
        self.getpidcmd='pidof '
        self.dhcp_enabled=True
        
    def checkPackageInstalled(self,p):
        if Run("rpm -q " + p,chk_err=False):
            return 0
        else:
            return 1

def checkPackageUpdateable(self,p):
        if Run("zypper list-updates | grep " + p,chk_err=False):
            return 1
        else:
            return 0

def installAgentServiceScriptFiles(self):
        try:
            SetFileContents(self.init_script_file, self.init_file)
            os.chmod(self.init_script_file, 0744)
        except:
            pass
        
    def registerAgentService(self):
        self.installAgentServiceScriptFiles()
        return Run('insserv ' + self.agent_service_name)

def uninstallAgentService(self):
        return Run('insserv -r ' + self.agent_service_name)

def unregisterAgentService(self):
        self.stopAgentService()
        return self.uninstallAgentService()

def startDHCP(self):
        Run("service " + self.dhcp_client_name + " start", chk_err=False)

def stopDHCP(self):
        Run("service " + self.dhcp_client_name + " stop", chk_err=False)
    
############################################################    
#	redhatDistro
############################################################

redhat_init_file= """\
#!/bin/bash
#
# Init file for AzureLinuxAgent.
#
# chkconfig: 2345 60 80
# description: AzureLinuxAgent
#

# source function library
. /etc/rc.d/init.d/functions

RETVAL=0
FriendlyName="AzureLinuxAgent"
WAZD_BIN=/usr/sbin/waagent

start()
{
    echo -n $"Starting $FriendlyName: "
    $WAZD_BIN -daemon &
}

stop()
{
    echo -n $"Stopping $FriendlyName: "
    killproc -p /var/run/waagent.pid $WAZD_BIN
    RETVAL=$?
    echo
    return $RETVAL
}

case "$1" in
    start)
        start
        ;;
    stop)
        stop
        ;;
    restart)
        stop
        start
        ;;
    reload)
        ;;
    report)
        ;;
    status)
        status $WAZD_BIN
        RETVAL=$?
        ;;
    *)
        echo $"Usage: $0 {start|stop|restart|status}"
        RETVAL=1
esac
exit $RETVAL
"""

class redhatDistro(AbstractDistro):
    """
    Redhat Distro concrete class
    Put Redhat specific behavior here...
    """
    def __init__(self):
        super(redhatDistro,self).__init__()
        self.service_cmd='/sbin/service'
        self.ssh_service_restart_option='condrestart'
        self.ssh_service_name='sshd'
        self.hostname_file_path= None if DistInfo()[1] < '7.0' else '/etc/hostname'
        self.init_file=redhat_init_file
        self.grubKernelBootOptionsFile = '/boot/grub/menu.lst'
        self.grubKernelBootOptionsLine = 'kernel'

def publishHostname(self,name):
        super(redhatDistro,self).publishHostname(name)
        if DistInfo()[1] < '7.0' :
            filepath = "/etc/sysconfig/network"
            if os.path.isfile(filepath):
                ReplaceFileContentsAtomic(filepath, "HOSTNAME=" + name + "\n"
                    + "\n".join(filter(lambda a: not a.startswith("HOSTNAME"), GetFileContents(filepath).split('\n'))))

ethernetInterface = MyDistro.GetInterfaceName()
        filepath = "/etc/sysconfig/network-scripts/ifcfg-" + ethernetInterface
        if os.path.isfile(filepath):
            ReplaceFileContentsAtomic(filepath, "DHCP_HOSTNAME=" + name + "\n"
                    + "\n".join(filter(lambda a: not a.startswith("DHCP_HOSTNAME"), GetFileContents(filepath).split('\n'))))
        return 0

def installAgentServiceScriptFiles(self):
        SetFileContents(self.init_script_file, self.init_file)
        os.chmod(self.init_script_file, 0744)
        return 0

def registerAgentService(self):
        self.installAgentServiceScriptFiles()
        return Run('chkconfig --add waagent')
   
    def uninstallAgentService(self):
        return Run('chkconfig --del ' + self.agent_service_name)

def unregisterAgentService(self):
        self.stopAgentService()
        return self.uninstallAgentService()
    
    def checkPackageInstalled(self,p):
        if Run("yum list installed " + p,chk_err=False):
            return 0
        else:
            return 1

def checkPackageUpdateable(self,p):
        if Run("yum check-update | grep "+ p,chk_err=False):
            return 1
        else:
            return 0

def checkDependencies(self):
        """
        Generic dependency check.
        Return 1 unless all dependencies are satisfied.
        """
        if DistInfo()[1] < '7.0' and self.checkPackageInstalled('NetworkManager'):
            Error(GuestAgentLongName + " is not compatible with network-manager.")
            return 1
        try:
            m= __import__('pyasn1')
        except ImportError:
            Error(GuestAgentLongName + " requires python-pyasn1 for your Linux distribution.")
            return 1
        for a in self.requiredDeps:
            if Run("which " + a + " > /dev/null 2>&1",chk_err=False):
                Error("Missing required dependency: " + a)
                return 1
        return 0

############################################################    
#	centosDistro
############################################################

class centosDistro(redhatDistro):
    """
    CentOS Distro concrete class
    Put CentOS specific behavior here...
    """
    def __init__(self):
        super(centosDistro,self).__init__()

############################################################    
#   eulerosDistro
############################################################

class eulerosDistro(redhatDistro):
    """
    EulerOS Distro concrete class
    Put EulerOS specific behavior here...
    """
    def __init__(self):
        super(eulerosDistro,self).__init__()

############################################################    
#	oracleDistro
############################################################

class oracleDistro(redhatDistro):
    """
    Oracle Distro concrete class
    Put Oracle specific behavior here...
    """
    def __init__(self):
        super(oracleDistro, self).__init__()

############################################################    
#	asianuxDistro
############################################################

class asianuxDistro(redhatDistro):
    """
    Asianux Distro concrete class
    Put Asianux specific behavior here...
    """
    def __init__(self):
        super(asianuxDistro,self).__init__()

############################################################
#   CoreOSDistro
############################################################

class CoreOSDistro(AbstractDistro):
    """
    CoreOS Distro concrete class
    Put CoreOS specific behavior here...
    """
    CORE_UID = 500

def __init__(self):
        super(CoreOSDistro,self).__init__()
        self.requiredDeps += [ "/usr/bin/systemctl" ]
        self.agent_service_name = 'waagent'
        self.init_script_file='/etc/systemd/system/waagent.service'
        self.fileBlackList.append("/etc/machine-id")
        self.dhcp_client_name='systemd-networkd'
        self.getpidcmd='pidof '
        self.shadow_file_mode=0640
        self.waagent_path='/usr/share/oem/bin'
        self.python_path='/usr/share/oem/python/bin'
        self.dhcp_enabled=True
        if 'PATH' in os.environ:
            os.environ['PATH'] = "{0}:{1}".format(os.environ['PATH'], self.python_path)
        else:
            os.environ['PATH'] = self.python_path

if 'PYTHONPATH' in os.environ:
            os.environ['PYTHONPATH'] = "{0}:{1}".format(os.environ['PYTHONPATH'], self.waagent_path)
        else:
            os.environ['PYTHONPATH'] = self.waagent_path

def checkPackageInstalled(self,p):
        """
        There is no package manager in CoreOS.  Return 1 since it must be preinstalled.
        """
        return 1

def checkDependencies(self):
        for a in self.requiredDeps:
            if Run("which " + a + " > /dev/null 2>&1",chk_err=False):
                Error("Missing required dependency: " + a)
                return 1
        return 0

def checkPackageUpdateable(self,p):
        """
        There is no package manager in CoreOS.  Return 0 since it can't be updated via package.
        """
        return 0

def startAgentService(self):
        return Run('systemctl start ' + self.agent_service_name)

def stopAgentService(self):
        return Run('systemctl stop ' + self.agent_service_name)

def restartSshService(self):
        """
        SSH is socket activated on CoreOS. No need to restart it.
        """
        return 0

def sshDeployPublicKey(self,fprint,path):
        """
        We support PKCS8.
        """
        if Run("ssh-keygen -i -m PKCS8 -f " + fprint + " >> " + path):
            return 1
        else :
            return 0

def RestartInterface(self, iface):
        Run("systemctl restart systemd-networkd")

def startDHCP(self):
        Run("systemctl start " + self.dhcp_client_name, chk_err=False)

def stopDHCP(self):
        Run("systemctl stop " + self.dhcp_client_name, chk_err=False)

def translateCustomData(self, data):
        return base64.b64decode(data)

def getConfigurationPath(self):
        return "/usr/share/oem/waagent.conf"

############################################################    
#	debianDistro
############################################################    
debian_init_file = """\
#!/bin/sh
### BEGIN INIT INFO
# Provides:          AzureLinuxAgent
# Required-Start:    $network $syslog
# Required-Stop:     $network $syslog
# Should-Start:      $network $syslog
# Should-Stop:       $network $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: AzureLinuxAgent
# Description:       AzureLinuxAgent
### END INIT INFO

. /lib/lsb/init-functions

OPTIONS="-daemon"
WAZD_BIN=/usr/sbin/waagent
WAZD_PID=/var/run/waagent.pid

case "$1" in
    start)
        log_begin_msg "Starting AzureLinuxAgent..."
        pid=$( pidofproc $WAZD_BIN )
        if [ -n "$pid" ] ; then
              log_begin_msg "Already running."
              log_end_msg 0
              exit 0
        fi
        start-stop-daemon --start --quiet --oknodo --background --exec $WAZD_BIN -- $OPTIONS
        log_end_msg $?
        ;;

stop)
        log_begin_msg "Stopping AzureLinuxAgent..."
        start-stop-daemon --stop --quiet --oknodo --pidfile $WAZD_PID
        ret=$?
        rm -f $WAZD_PID
        log_end_msg $ret
        ;;
    force-reload)
        $0 restart
        ;;
    restart)
        $0 stop
        $0 start
        ;;
    status)
        status_of_proc $WAZD_BIN && exit 0 || exit $?
        ;;
    *)
        log_success_msg "Usage: /etc/init.d/waagent {start|stop|force-reload|restart|status}"
        exit 1
        ;;
esac

exit 0
"""

class debianDistro(AbstractDistro):
    """
    debian Distro concrete class
    Put debian specific behavior here...
    """
    def __init__(self):
        super(debianDistro,self).__init__()
        self.requiredDeps += [ "/usr/sbin/update-rc.d" ]
        self.init_file=debian_init_file
        self.agent_package_name='walinuxagent'
        self.dhcp_client_name='dhclient'
        self.getpidcmd='pidof '
        self.shadow_file_mode=0640

def checkPackageInstalled(self,p):
        """
        Check that the package is installed.
        Return 1 if installed, 0 if not installed.
        This method of using dpkg-query
        allows wildcards to be present in the
        package name.
        """
        if not Run("dpkg-query -W -f='${Status}\n' '" + p + "' | grep ' installed' 2>&1",chk_err=False):
            return 1
        else:
            return 0
        
    def checkDependencies(self):
        """
        Debian dependency check.  python-pyasn1 is NOT needed.
        Return 1 unless all dependencies are satisfied.
        NOTE: using network*manager will catch either package name in Ubuntu or debian.
        """
        if self.checkPackageInstalled('network*manager'):
            Error(GuestAgentLongName + " is not compatible with network-manager.")
            return 1
        for a in self.requiredDeps:
            if Run("which " + a + " > /dev/null 2>&1",chk_err=False):
                Error("Missing required dependency: " + a)
                return 1
        return 0

def checkPackageUpdateable(self,p):
        if Run("apt-get update ; apt-get upgrade -us | grep " + p,chk_err=False):
            return 1
        else:
            return 0
            
    def installAgentServiceScriptFiles(self):
        """
        If we are packaged - the service name is walinuxagent, do nothing.
        """
        if self.agent_service_name == 'walinuxagent':
            return 0
        try:
            SetFileContents(self.init_script_file, self.init_file)
            os.chmod(self.init_script_file, 0744)
        except OSError, e:
            ErrorWithPrefix('installAgentServiceScriptFiles','Exception: '+str(e)+' occured creating ' + self.init_script_file)
            return 1
        return 0
    
    def registerAgentService(self):
        if self.installAgentServiceScriptFiles() == 0:
            return Run('update-rc.d waagent defaults')
        else :
            return 1
    
    def uninstallAgentService(self):
        return Run('update-rc.d -f ' + self.agent_service_name + ' remove')

def unregisterAgentService(self):
        self.stopAgentService()
        return self.uninstallAgentService()
    
    def sshDeployPublicKey(self,fprint,path):
        """
        We support PKCS8.
        """
        if Run("ssh-keygen -i -m PKCS8 -f " + fprint + " >> " + path):
            return 1
        else :
            return 0
        
############################################################    
#	KaliDistro - WIP
#       Functioning on Kali 1.1.0a so far
############################################################ 
class KaliDistro(debianDistro):
    """
    Kali Distro concrete class
    Put Kali specific behavior here...
    """
    def __init__(self):
        super(KaliDistro,self).__init__()

############################################################    
#	UbuntuDistro
############################################################    
ubuntu_upstart_file = """\
#walinuxagent - start Azure agent

description "walinuxagent"
author "Ben Howard <ben.howard@canonical.com>"

start on (filesystem and started rsyslog)

pre-start script

WALINUXAGENT_ENABLED=1
    [ -r /etc/default/walinuxagent ] && . /etc/default/walinuxagent

if [ "$WALINUXAGENT_ENABLED" != "1" ]; then
        exit 1
    fi

if [ ! -x /usr/sbin/waagent ]; then
        exit 1
    fi

#Load the udf module
    modprobe -b udf
end script

exec /usr/sbin/waagent -daemon
"""

class UbuntuDistro(debianDistro):
    """
    Ubuntu Distro concrete class
    Put Ubuntu specific behavior here...
    """
    def __init__(self):
        super(UbuntuDistro,self).__init__()
        self.init_script_file='/etc/init/waagent.conf'
        self.init_file=ubuntu_upstart_file
        self.fileBlackList = [ "/root/.bash_history", "/var/log/waagent.log"]
        self.dhcp_client_name=None
        self.getpidcmd='pidof '

def registerAgentService(self):
        return self.installAgentServiceScriptFiles()
    
    def uninstallAgentService(self):
        """
        If we are packaged - the service name is walinuxagent, do nothing.
        """
        if self.agent_service_name == 'walinuxagent':
            return 0
        os.remove('/etc/init/' + self.agent_service_name + '.conf')

def unregisterAgentService(self):
        """
        If we are packaged - the service name is walinuxagent, do nothing.
        """
        if self.agent_service_name == 'walinuxagent':
            return
        self.stopAgentService()
        return self.uninstallAgentService()
    
    def deprovisionWarnUser(self):
        """
        Ubuntu specific warning string from Deprovision.
        """
        print("WARNING! Nameserver configuration in /etc/resolvconf/resolv.conf.d/{tail,original} will be deleted.")

def deprovisionDeleteFiles(self):
        """
        Ubuntu uses resolv.conf by default, so removing /etc/resolv.conf will
        break resolvconf. Therefore, we check to see if resolvconf is in use,
        and if so, we remove the resolvconf artifacts.
        """
        if os.path.realpath('/etc/resolv.conf') != '/run/resolvconf/resolv.conf':
            Log("resolvconf is not configured. Removing /etc/resolv.conf")
            self.fileBlackList.append('/etc/resolv.conf')
        else:
            Log("resolvconf is enabled; leaving /etc/resolv.conf intact")
            resolvConfD = '/etc/resolvconf/resolv.conf.d/'
            self.fileBlackList.extend([resolvConfD + 'tail', resolvConfD + 'original'])
        for f in os.listdir(LibDir)+self.fileBlackList:
            try:
                os.remove(f)
            except:
                pass
        return 0

def getDhcpClientName(self):
        if self.dhcp_client_name != None :
            return self.dhcp_client_name
        if DistInfo()[1] == '12.04' :
            self.dhcp_client_name='dhclient3'
        else :
            self.dhcp_client_name='dhclient'
        return self.dhcp_client_name

def waitForSshHostKey(self, path):
        """
        Wait until the ssh host key is generated by cloud init.
        """
        for retry in range(0, 10):
            if(os.path.isfile(path)):
                return True
            time.sleep(1)
        Error("Can't find host key: {0}".format(path))
        return False

############################################################    
#	LinuxMintDistro
############################################################

class LinuxMintDistro(UbuntuDistro):
    """
    LinuxMint Distro concrete class
    Put LinuxMint specific behavior here...
    """
    def __init__(self):
        super(LinuxMintDistro,self).__init__()

############################################################    
#	fedoraDistro
############################################################    
fedora_systemd_service = """\
[Unit]
Description=Azure Linux Agent
After=network.target
After=sshd.service
ConditionFileIsExecutable=/usr/sbin/waagent
ConditionPathExists=/etc/waagent.conf

[Service]
Type=simple
ExecStart=/usr/sbin/waagent -daemon

[Install]
WantedBy=multi-user.target
"""

class fedoraDistro(redhatDistro):
    """
    FedoraDistro concrete class
    Put Fedora specific behavior here...
    """
    def __init__(self):
        super(fedoraDistro,self).__init__()
        self.service_cmd = '/usr/bin/systemctl'
        self.hostname_file_path = '/etc/hostname'
        self.init_script_file = '/usr/lib/systemd/system/' + self.agent_service_name + '.service'
        self.init_file = fedora_systemd_service
        self.grubKernelBootOptionsFile = '/etc/default/grub'
        self.grubKernelBootOptionsLine = 'GRUB_CMDLINE_LINUX='

def publishHostname(self, name):
        SetFileContents(self.hostname_file_path, name + '\n')
        ethernetInterface = MyDistro.GetInterfaceName()
        filepath = "/etc/sysconfig/network-scripts/ifcfg-" + ethernetInterface
        if os.path.isfile(filepath):
            ReplaceFileContentsAtomic(filepath, "DHCP_HOSTNAME=" + name + "\n"
                    + "\n".join(filter(lambda a: not a.startswith("DHCP_HOSTNAME"), GetFileContents(filepath).split('\n'))))
        return 0

def installAgentServiceScriptFiles(self):
        SetFileContents(self.init_script_file, self.init_file)
        os.chmod(self.init_script_file, 0644)
        return Run(self.service_cmd + ' daemon-reload')

def registerAgentService(self):
        self.installAgentServiceScriptFiles()
        return Run(self.service_cmd + ' enable ' + self.agent_service_name)

def uninstallAgentService(self):
        """
        Call service subsystem to remove waagent script.
        """
        return Run(self.service_cmd + ' disable ' + self.agent_service_name)

def startAgentService(self):
        """
        Service call to start the Agent service
        """
        return Run(self.service_cmd + ' start ' + self.agent_service_name)

def stopAgentService(self):
        """
        Service call to stop the Agent service
        """
        return Run(self.service_cmd + ' stop '  + self.agent_service_name, False)

def restartSshService(self):
        """
        Service call to re(start) the SSH service
        """
        sshRestartCmd = self.service_cmd + " " +  self.ssh_service_restart_option + " " + self.ssh_service_name
        retcode = Run(sshRestartCmd)
        if retcode > 0:
            Error("Failed to restart SSH service with return code:" + str(retcode))
        return retcode

def checkPackageInstalled(self, p):
        """
        Query package database for prescence of an installed package.
        """
        import rpm
        ts = rpm.TransactionSet()
        rpms = ts.dbMatch(rpm.RPMTAG_PROVIDES, p)
        return bool(len(rpms) > 0)

def deleteRootPassword(self):
        return Run("/sbin/usermod root -p '!!'")

if not os.path.exists(buildroot+'/etc/logrotate.d'):
            os.mkdir(buildroot+'/etc/logrotate.d')
        SetFileContents(buildroot+'/etc/logrotate.d/WALinuxAgent', WaagentLogrotate)

self.init_script_file=buildroot+self.init_script_file
        # this allows us to call installAgentServiceScriptFiles()
        if not os.path.exists(os.path.dirname(self.init_script_file)):
            os.mkdir(os.path.dirname(self.init_script_file))
        self.installAgentServiceScriptFiles()

def CreateAccount(self, user, password, expiration, thumbprint):
        super(fedoraDistro, self).CreateAccount(user, password, expiration, thumbprint)
        Run('/sbin/usermod ' + user + ' -G wheel')

def DeleteAccount(self, user):
        Run('/sbin/usermod ' + user + ' -G ""')
        super(fedoraDistro, self).DeleteAccount(user)

############################################################    
#	FreeBSD
############################################################    
FreeBSDWaagentConf = """\
#
# Azure Linux Agent Configuration
#

ResourceDisk.Format=y                   # Format if unformatted. If 'n', resource disk will not be mounted.
ResourceDisk.Filesystem=ufs2            #
ResourceDisk.MountPoint=/mnt/resource   #
ResourceDisk.EnableSwap=n               # Create and use swapfile on resource disk.
ResourceDisk.SwapSizeMB=0               # Size of the swapfile.

LBProbeResponder=y                      # Respond to load balancer probes if requested by Azure.

Logs.Verbose=n                          # Enable verbose logs

OS.RootDeviceScsiTimeout=300            # Root device timeout in seconds.
OS.OpensslPath=None                     # If "None", the system default version is used.
"""

bsd_init_file="""\
#! /bin/sh

# PROVIDE: waagent
# REQUIRE: DAEMON cleanvar sshd
# BEFORE: LOGIN
# KEYWORD: nojail

. /etc/rc.subr
export PATH=$PATH:/usr/local/bin
name="waagent"
rcvar="waagent_enable"
command="/usr/sbin/${name}"
command_interpreter="/usr/local/bin/python"
waagent_flags=" daemon &"

pidfile="/var/run/waagent.pid"

load_rc_config $name
run_rc_command "$1"

"""
bsd_activate_resource_disk_txt="""\
#!/usr/bin/env python

import os
import sys
import imp

# waagent has no '.py' therefore create waagent module import manually.
__name__='setupmain' #prevent waagent.__main__ from executing
waagent=imp.load_source('waagent','/tmp/waagent') 
waagent.LoggerInit('/var/log/waagent.log','/dev/console')
from waagent import RunGetOutput,Run
Config=waagent.ConfigurationProvider(None)
format = Config.get("ResourceDisk.Format")
if format == None or format.lower().startswith("n"):
    sys.exit(0)
device_base = 'da1'
device = "/dev/" + device_base
for entry in RunGetOutput("mount")[1].split():
    if entry.startswith(device + "s1"):
        waagent.Log("ActivateResourceDisk: " + device + "s1 is already mounted.")
        sys.exit(0)
mountpoint = Config.get("ResourceDisk.MountPoint")
if mountpoint == None:
    mountpoint = "/mnt/resource"
waagent.CreateDir(mountpoint, "root", 0755)
fs = Config.get("ResourceDisk.Filesystem")
if waagent.FreeBSDDistro().mediaHasFilesystem(device) == False :
    Run("newfs " + device + "s1")
if Run("mount " + device + "s1 " + mountpoint):
    waagent.Error("ActivateResourceDisk: Failed to mount resource disk (" + device + "s1).")
    sys.exit(0)
waagent.Log("Resource disk (" + device + "s1) is mounted at " + mountpoint + " with fstype " + fs)
waagent.SetFileContents(os.path.join(mountpoint,waagent.README_FILENAME), waagent.README_FILECONTENT)
swap = Config.get("ResourceDisk.EnableSwap")
if swap == None or swap.lower().startswith("n"):
    sys.exit(0)
sizeKB = int(Config.get("ResourceDisk.SwapSizeMB")) * 1024
if os.path.isfile(mountpoint + "/swapfile") and os.path.getsize(mountpoint + "/swapfile") != (sizeKB * 1024):
    os.remove(mountpoint + "/swapfile")
if not os.path.isfile(mountpoint + "/swapfile"):
    Run("umask 0077 && dd if=/dev/zero of=" + mountpoint + "/swapfile bs=1024 count=" + str(sizeKB))
if Run("mdconfig -a -t vnode -f " + mountpoint + "/swapfile -u 0"):
    waagent.Error("ActivateResourceDisk: Configuring swap - Failed to create md0")
if not Run("swapon /dev/md0"):
    waagent.Log("Enabled " + str(sizeKB) + " KB of swap at " + mountpoint + "/swapfile")
else:
    waagent.Error("ActivateResourceDisk: Failed to activate swap at " + mountpoint + "/swapfile")
"""

class FreeBSDDistro(AbstractDistro):
    """
    """
    def __init__(self):
        """
        Generic Attributes go here.  These are based on 'majority rules'.
        This __init__() may be called or overriden by the child.
        """
        super(FreeBSDDistro,self).__init__()
        self.agent_service_name = os.path.basename(sys.argv[0]) 
        self.selinux=False
        self.ssh_service_name='sshd'
        self.ssh_config_file='/etc/ssh/sshd_config'
        self.hostname_file_path='/etc/hostname'
        self.dhcp_client_name='dhclient'
        self.requiredDeps = [ 'route', 'shutdown', 'ssh-keygen', 'pw'
                              , 'openssl', 'fdisk', 'sed', 'grep' , 'sudo']
        self.init_script_file='/etc/rc.d/waagent'
        self.init_file=bsd_init_file
        self.agent_package_name='WALinuxAgent'
        self.fileBlackList = [ "/root/.bash_history", "/var/log/waagent.log",'/etc/resolv.conf' ]        
        self.agent_files_to_uninstall = ["/etc/waagent.conf"]
        self.grubKernelBootOptionsFile = '/boot/loader.conf'
        self.grubKernelBootOptionsLine = ''
        self.getpidcmd = 'pgrep -n'
        self.mount_dvd_cmd = 'dd bs=2048 count=33 skip=295 if=' # custom data max len is 64k 
        self.sudoers_dir_base = '/usr/local/etc'
        self.waagent_conf_file = FreeBSDWaagentConf
        
    def installAgentServiceScriptFiles(self):
        SetFileContents(self.init_script_file, self.init_file)
        os.chmod(self.init_script_file, 0777)
        AppendFileContents("/etc/rc.conf","waagent_enable='YES'\n")
        return 0

def registerAgentService(self):
        self.installAgentServiceScriptFiles()
        return Run("services_mkdb " + self.init_script_file)

def deleteRootPassword(self):
        """
        BSD root password removal.
        """
        filepath="/etc/master.passwd"
        ReplaceStringInFile(filepath,r'root:.*?:','root::')
        #ReplaceFileContentsAtomic(filepath,"root:*LOCK*:14600::::::\n"
        #                          + "\n".join(filter(lambda a: not a.startswith("root:"),GetFileContents(filepath).split('\n'))))
        os.chmod(filepath,self.shadow_file_mode)
        if self.isSelinuxSystem():
            self.setSelinuxContext(filepath,'system_u:object_r:shadow_t:s0')
        RunGetOutput("pwd_mkdb -u root /etc/master.passwd")
        Log("Root password deleted.")
        return 0

def changePass(self,user,password):
        return RunSendStdin("pw usermod " + user + " -h 0 ",password, log_cmd=False)
    
    def load_ata_piix(self):
        return 0

def unload_ata_piix(self):
        return 0

def checkDependencies(self):
        """
        FreeBSD dependency check.
        Return 1 unless all dependencies are satisfied.
        """
        for a in self.requiredDeps:
            if Run("which " + a + " > /dev/null 2>&1",chk_err=False):
                Error("Missing required dependency: " + a)
                return 1
        return 0

def packagedInstall(self,buildroot):
        pass

def GetInterfaceName(self):
        """
        Return the ip of the 
        active ethernet interface.
        """
        iface,inet,mac=self.GetFreeBSDEthernetInfo()
        return iface

def RestartInterface(self, iface):
        Run("service netif restart")

def GetIpv4Address(self):
        """
        Return the ip of the 
        active ethernet interface.
        """
        iface,inet,mac=self.GetFreeBSDEthernetInfo()
        return inet

def GetMacAddress(self):
        """
        Return the ip of the 
        active ethernet interface.
        """
        iface,inet,mac=self.GetFreeBSDEthernetInfo()
        l=mac.split(':')
        r=[]
        for i in l:
            r.append(string.atoi(i,16))
        return r

def GetFreeBSDEthernetInfo(self):
        """
        There is no SIOCGIFCONF
        on freeBSD - just parse ifconfig.
        Returns strings: iface, inet4_addr, and mac
        or 'None,None,None' if unable to parse.
        We will sleep and retry as the network must be up.
        """
        code,output=RunGetOutput("ifconfig",chk_err=False)
        Log(output)
        retries=10
        cmd='ifconfig | grep -A2 -B2 ether | grep -B3 inet | grep -A4 UP '
        code=1

while code > 0 :
            if code > 0 and retries == 0:
                Error("GetFreeBSDEthernetInfo - Failed to detect ethernet interface")
                return None, None, None
            code,output=RunGetOutput(cmd,chk_err=False)
            retries-=1
            if code > 0 and retries > 0 :
                Log("GetFreeBSDEthernetInfo - Error: retry ethernet detection " + str(retries))
                if retries == 9 :
                    c,o=RunGetOutput("ifconfig | grep -A1 -B2 ether",chk_err=False)
                    if c == 0:
                        t=o.replace('\n',' ')
                        t=t.split()
                        i=t[0][:-1]
                        Log(RunGetOutput('id')[1])
                        Run('dhclient '+i)
                time.sleep(10)

j=output.replace('\n',' ')
        j=j.split()
        iface=j[0][:-1]

for i in range(len(j)):
            if j[i] == 'inet' :
                inet=j[i+1]
            elif j[i] == 'ether' :
                mac=j[i+1]

return iface, inet, mac

def CreateAccount(self,user, password, expiration, thumbprint):
        """
        Create a user account, with 'user', 'password', 'expiration', ssh keys
        and sudo permissions.
        Returns None if successful, error string on failure.
        """
        userentry = None
        try:
            userentry = pwd.getpwnam(user)
        except:
            pass
        uidmin = None
        try:
            if os.path.isfile("/etc/login.defs"):
                uidmin = int(GetLineStartingWith("UID_MIN", "/etc/login.defs").split()[1])
        except:
            pass
        if uidmin == None:
            uidmin = 100
        if userentry != None and userentry[2] < uidmin:
            Error("CreateAccount: " + user + " is a system user. Will not set password.")
            return "Failed to set password for system user: " + user + " (0x06)."
        if userentry == None:
            command = "pw useradd " + user + " -m"
            if expiration != None:
                command += " -e " + expiration.split('.')[0]
            if Run(command):
                Error("Failed to create user account: " + user)
                return "Failed to create user account: " + user + " (0x07)."
            else:
                Log("CreateAccount: " + user + " already exists. Will update password.")
        
        if password != None:
            self.changePass(user,password)
        try:
            # for older distros create sudoers.d
            if not os.path.isdir(MyDistro.sudoers_dir_base+'/sudoers.d/'):
                # create the /etc/sudoers.d/ directory
                os.mkdir(MyDistro.sudoers_dir_base+'/sudoers.d')
                # add the include of sudoers.d to the /etc/sudoers
                SetFileContents(MyDistro.sudoers_dir_base+'/sudoers',GetFileContents(MyDistro.sudoers_dir_base+'/sudoers')+'\n#includedir ' + MyDistro.sudoers_dir_base + '/sudoers.d\n')
            if password == None:
                SetFileContents(MyDistro.sudoers_dir_base+"/sudoers.d/waagent", user + " ALL = (ALL) NOPASSWD: ALL\n")
            else:
                SetFileContents(MyDistro.sudoers_dir_base+"/sudoers.d/waagent", user + " ALL = (ALL) ALL\n")
            os.chmod(MyDistro.sudoers_dir_base+"/sudoers.d/waagent", 0440)
        except:
            Error("CreateAccount: Failed to configure sudo access for user.")
            return "Failed to configure sudo privileges (0x08)."
        home = MyDistro.GetHome()
        if thumbprint != None:
            dir = home + "/" + user + "/.ssh"
            CreateDir(dir, user, 0700)
            pub = dir + "/id_rsa.pub"
            prv = dir + "/id_rsa"
            Run("ssh-keygen -y -f " + thumbprint + ".prv > " + pub)
            SetFileContents(prv, GetFileContents(thumbprint + ".prv"))
            for f in [pub, prv]:
                os.chmod(f, 0600)
                ChangeOwner(f, user)
            SetFileContents(dir + "/authorized_keys", GetFileContents(pub))
            ChangeOwner(dir + "/authorized_keys", user)
        Log("Created user account: " + user)
        return None
    
    def DeleteAccount(self,user):
        """
        Delete the 'user'.
        Clear utmp first, to avoid error.
        Removes the /etc/sudoers.d/waagent file.
        """
        userentry = None
        try:
            userentry = pwd.getpwnam(user)
        except:
            pass
        if userentry == None:
            Error("DeleteAccount: " + user + " not found.")
            return
        uidmin = None
        try:
            if os.path.isfile("/etc/login.defs"):
                uidmin = int(GetLineStartingWith("UID_MIN", "/etc/login.defs").split()[1])
        except:
            pass
        if uidmin == None:
            uidmin = 100
        if userentry[2] < uidmin:
            Error("DeleteAccount: " + user + " is a system user. Will not delete account.")
            return
        Run("> /var/run/utmp") #Delete utmp to prevent error if we are the 'user' deleted
        pid = subprocess.Popen(['rmuser', '-y', user], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).pid
        try:
            os.remove(MyDistro.sudoers_dir_base+"/sudoers.d/waagent")
        except:
            pass
        return

def ActivateResourceDiskNoThread(self):
        """
        Format, mount, and if specified in the configuration
        set resource disk as swap.
        """
        global DiskActivated
        Run('cp /usr/sbin/waagent /tmp/')
        SetFileContents('/tmp/bsd_activate_resource_disk.py',bsd_activate_resource_disk_txt)
        Run('chmod +x /tmp/bsd_activate_resource_disk.py')
        pid = subprocess.Popen(["/tmp/bsd_activate_resource_disk.py", ""]).pid
        Log("Spawning bsd_activate_resource_disk.py")
        DiskActivated = True
        return

def Install(self):
        """
        Install the agent service.
        Check dependencies.
        Create /etc/waagent.conf and move old version to
        /etc/waagent.conf.old
        Copy RulesFiles to /var/lib/waagent
        Create /etc/logrotate.d/waagent
        Set /etc/ssh/sshd_config ClientAliveInterval to 180
        Call ApplyVNUMAWorkaround()
        """
        if MyDistro.checkDependencies():
            return 1
        os.chmod(sys.argv[0], 0755)
        SwitchCwd()
        for a in RulesFiles:
            if os.path.isfile(a):
                if os.path.isfile(GetLastPathElement(a)):
                    os.remove(GetLastPathElement(a))
                shutil.move(a, ".")
                Warn("Moved " + a + " -> " + LibDir + "/" + GetLastPathElement(a) )
        MyDistro.registerAgentService()
        if os.path.isfile("/etc/waagent.conf"):
            try:
                os.remove("/etc/waagent.conf.old")
            except:
                pass
            try:
                os.rename("/etc/waagent.conf", "/etc/waagent.conf.old")
                Warn("Existing /etc/waagent.conf has been renamed to /etc/waagent.conf.old")
            except:
                pass
        SetFileContents("/etc/waagent.conf", self.waagent_conf_file)
        if os.path.exists('/usr/local/etc/logrotate.d/'):
            SetFileContents("/usr/local/etc/logrotate.d/waagent", WaagentLogrotate)
        filepath = "/etc/ssh/sshd_config"
        ReplaceFileContentsAtomic(filepath, "\n".join(filter(lambda a: not
            a.startswith("ClientAliveInterval"),
            GetFileContents(filepath).split('\n'))) + "\nClientAliveInterval 180\n")
        Log("Configured SSH client probing to keep connections alive.")
        #ApplyVNUMAWorkaround()
        return 0
    
    def mediaHasFilesystem(self,dsk):
        if Run('LC_ALL=C fdisk -p ' + dsk + ' | grep "invalid fdisk partition table found" ',False):
            return False
        return True
    
    def mountDVD(self,dvd,location):
        #At this point we cannot read a joliet option udf DVD in freebsd10 - so we 'dd' it into our location
        retcode,out = RunGetOutput(self.mount_dvd_cmd + dvd + ' of=' + location + '/ovf-env.xml')
        if retcode != 0:
            return retcode,out

ovfxml = (GetFileContents(location+"/ovf-env.xml",asbin=False))
        if ord(ovfxml[0]) > 128 and ord(ovfxml[1]) > 128 and ord(ovfxml[2]) > 128 :
            ovfxml = ovfxml[3:] # BOM is not stripped. First three bytes are > 128 and not unicode chars so we ignore them.
        ovfxml = ovfxml.strip(chr(0x00))
        ovfxml = "".join(filter(lambda x: ord(x)<128, ovfxml))
        ovfxml = re.sub(r'</Environment>.*\Z','',ovfxml,0,re.DOTALL)
        ovfxml += '</Environment>'
        SetFileContents(location+"/ovf-env.xml", ovfxml)
        return retcode,out

def GetHome(self):
        return '/home'

def initScsiDiskTimeout(self):
        """
        Set the SCSI disk timeout by updating the kernal config
        """
        timeout = Config.get("OS.RootDeviceScsiTimeout") 
        if timeout:
            Run("sysctl kern.cam.da.default_timeout=" + timeout)

def setScsiDiskTimeout(self):
        return

def setBlockDeviceTimeout(self, device, timeout):
        return

def getProcessorCores(self):
        return int(RunGetOutput("sysctl hw.ncpu | awk '{print $2}'")[1])
    
    def getTotalMemory(self):
        return int(RunGetOutput("sysctl hw.realmem | awk '{print $2}'")[1])/1024
    
    def setDefaultGateway(self, gateway):
        Run("/sbin/route add default " + gateway, chk_err=False)

def routeAdd(self, net, mask, gateway):
        Run("/sbin/route add -net " + net + " " + mask + " " + gateway, chk_err=False)

############################################################
# END DISTRO CLASS DEFS
############################################################

# This lets us index into a string or an array of integers transparently.
def Ord(a):
    """
    Allows indexing into a string or an array of integers transparently.
    Generic utility function.
    """
    if type(a) == type("a"):
        a = ord(a)
    return a

def IsLinux():
    """
    Returns True if platform is Linux.
    Generic utility function.
    """
    return (platform.uname()[0] == "Linux")

def GetLastPathElement(path):
    """
    Similar to basename.
    Generic utility function.
    """
    return path.rsplit('/', 1)[1]

def GetFileContents(filepath,asbin=False):
    """
    Read and return contents of 'filepath'.
    """
    mode='r'
    if asbin:
        mode+='b'
    c=None
    try:
        with open(filepath, mode) as F :
            c=F.read()
    except IOError, e:
        ErrorWithPrefix('GetFileContents','Reading from file ' + filepath + ' Exception is ' + str(e))
        return None        
    return c

def SetFileContents(filepath, contents):
    """
    Write 'contents' to 'filepath'.
    """
    if type(contents) == str :
        contents=contents.encode('latin-1', 'ignore')
    try:
        with open(filepath, "wb+") as F :
            F.write(contents)
    except IOError, e:
        ErrorWithPrefix('SetFileContents','Writing to file ' + filepath + ' Exception is ' + str(e))
        return None
    return 0

def AppendFileContents(filepath, contents):
    """
    Append 'contents' to 'filepath'.
    """
    if type(contents) == str :
        contents=contents.encode('latin-1')
    try: 
        with open(filepath, "a+") as F :
            F.write(contents)
    except IOError, e:
        ErrorWithPrefix('AppendFileContents','Appending to file ' + filepath + ' Exception is ' + str(e))
        return None
    return 0

def ReplaceFileContentsAtomic(filepath, contents):
    """
    Write 'contents' to 'filepath' by creating a temp file, and replacing original.
    """
    handle, temp = tempfile.mkstemp(dir = os.path.dirname(filepath))
    if type(contents) == str :
        contents=contents.encode('latin-1')
    try:
        os.write(handle, contents)
    except IOError, e:
        ErrorWithPrefix('ReplaceFileContentsAtomic','Writing to file ' + filepath + ' Exception is ' + str(e))
        return None
    finally:
        os.close(handle)
    try:
        os.rename(temp, filepath)
        return None
    except IOError, e:
        ErrorWithPrefix('ReplaceFileContentsAtomic','Renaming ' + temp+ ' to ' + filepath + ' Exception is ' + str(e))
    try:
        os.remove(filepath)
    except IOError, e:
        ErrorWithPrefix('ReplaceFileContentsAtomic','Removing '+ filepath + ' Exception is ' + str(e))
    try:
        os.rename(temp,filepath)
    except IOError, e:
        ErrorWithPrefix('ReplaceFileContentsAtomic','Removing '+ filepath + ' Exception is ' + str(e))
        return 1
    return 0

def GetLineStartingWith(prefix, filepath):
    """
    Return line from 'filepath' if the line startswith 'prefix'
    """
    for line in GetFileContents(filepath).split('\n'):
        if line.startswith(prefix):
            return line
    return None

def Run(cmd,chk_err=True):
    """
    Calls RunGetOutput on 'cmd', returning only the return code.
    If chk_err=True then errors will be reported in the log.
    If chk_err=False then errors will be suppressed from the log.
    """
    retcode,out=RunGetOutput(cmd,chk_err)
    return retcode

def RunGetOutput(cmd, chk_err=True, log_cmd=True):
    """
    Wrapper for subprocess.check_output.
    Execute 'cmd'.  Returns return code and STDOUT, trapping expected exceptions.
    Reports exceptions to Error if chk_err parameter is True
    """
    if log_cmd:
        LogIfVerbose(cmd)
    try:                                     
        output=subprocess.check_output(cmd,stderr=subprocess.STDOUT,shell=True)
    except subprocess.CalledProcessError,e :
        if chk_err and log_cmd:
            Error('CalledProcessError.  Error Code is ' + str(e.returncode)  )
            Error('CalledProcessError.  Command string was ' + e.cmd  )
            Error('CalledProcessError.  Command result was ' + (e.output[:-1]).decode('latin-1'))
        return e.returncode,e.output.decode('latin-1')
    return 0,output.decode('latin-1')

def RunSendStdin(cmd, input, chk_err=True, log_cmd=True):
    """
    Wrapper for subprocess.Popen.
    Execute 'cmd', sending 'input' to STDIN of 'cmd'.
    Returns return code and STDOUT, trapping expected exceptions.
    Reports exceptions to Error if chk_err parameter is True
    """
    if log_cmd:
        LogIfVerbose(cmd+input)
    try:                                     
        me=subprocess.Popen([cmd], shell=True, stdin=subprocess.PIPE,stderr=subprocess.STDOUT,stdout=subprocess.PIPE)
        output=me.communicate(input)
    except OSError , e :
        if chk_err and log_cmd:
            Error('CalledProcessError.  Error Code is ' + str(me.returncode)  )
            Error('CalledProcessError.  Command string was ' + cmd  )
            Error('CalledProcessError.  Command result was ' + output[0].decode('latin-1'))
            return 1,output[0].decode('latin-1')
    if me.returncode is not 0 and chk_err is True and log_cmd:
            Error('CalledProcessError.  Error Code is ' + str(me.returncode)  )
            Error('CalledProcessError.  Command string was ' + cmd  )
            Error('CalledProcessError.  Command result was ' + output[0].decode('latin-1'))
    return me.returncode,output[0].decode('latin-1')

def GetNodeTextData(a):
    """
    Filter non-text nodes from DOM tree
    """
    for b in a.childNodes:
        if b.nodeType == b.TEXT_NODE:
            return b.data

def GetHome():
    """
    Attempt to guess the $HOME location.
    Return the path string.
    """
    home = None
    try:
        home = GetLineStartingWith("HOME", "/etc/default/useradd").split('=')[1].strip()
    except:
        pass
    if (home == None) or (home.startswith("/") == False):
        home = "/home"
    return home

def ChangeOwner(filepath, user):
    """
    Lookup user.  Attempt chown 'filepath' to 'user'.
    """
    p = None
    try:
        p = pwd.getpwnam(user)
    except:
        pass
    if p != None:
        if not os.path.exists(filepath):
            Error("Path does not exist: {0}".format(filepath))
        else:
            os.chown(filepath, p[2], p[3])

def CreateDir(dirpath, user, mode):
    """
    Attempt os.makedirs, catch all exceptions.
    Call ChangeOwner afterwards.
    """
    try:
        os.makedirs(dirpath, mode)
    except:
        pass
    ChangeOwner(dirpath, user)

def CreateAccount(user, password, expiration, thumbprint):
    """
    Create a user account, with 'user', 'password', 'expiration', ssh keys
    and sudo permissions.
    Returns None if successful, error string on failure.
    """
    userentry = None
    try:
        userentry = pwd.getpwnam(user)
    except:
        pass
    uidmin = None
    try:
        uidmin = int(GetLineStartingWith("UID_MIN", "/etc/login.defs").split()[1])
    except:
        pass
    if uidmin == None:
        uidmin = 100
    if userentry != None and userentry[2] < uidmin:
        Error("CreateAccount: " + user + " is a system user. Will not set password.")
        return "Failed to set password for system user: " + user + " (0x06)."
    if userentry == None:
        command = "useradd -m " + user
        if expiration != None:
            command += " -e " + expiration.split('.')[0]
        if Run(command):
            Error("Failed to create user account: " + user)
            return "Failed to create user account: " + user + " (0x07)."
    else:
        Log("CreateAccount: " + user + " already exists. Will update password.")
    if password != None:
        MyDistro.changePass(user, password)
    try:
        # for older distros create sudoers.d
        if not os.path.isdir('/etc/sudoers.d/'):
            # create the /etc/sudoers.d/ directory
            os.mkdir('/etc/sudoers.d/')
            # add the include of sudoers.d to the /etc/sudoers
            SetFileContents('/etc/sudoers',GetFileContents('/etc/sudoers')+'\n#includedir /etc/sudoers.d\n')
        if password == None:
            SetFileContents("/etc/sudoers.d/waagent", user + " ALL = (ALL) NOPASSWD: ALL\n")
        else:
            SetFileContents("/etc/sudoers.d/waagent", user + " ALL = (ALL) ALL\n")
        os.chmod("/etc/sudoers.d/waagent", 0440)
    except:
        Error("CreateAccount: Failed to configure sudo access for user.")
        return "Failed to configure sudo privileges (0x08)."
    home = MyDistro.GetHome()
    if thumbprint != None:
        dir = home + "/" + user + "/.ssh"
        CreateDir(dir, user, 0700)
        pub = dir + "/id_rsa.pub"
        prv = dir + "/id_rsa"
        Run("ssh-keygen -y -f " + thumbprint + ".prv > " + pub)
        SetFileContents(prv, GetFileContents(thumbprint + ".prv"))
        for f in [pub, prv]:
            os.chmod(f, 0600)
            ChangeOwner(f, user)
        SetFileContents(dir + "/authorized_keys", GetFileContents(pub))
        ChangeOwner(dir + "/authorized_keys", user)
    Log("Created user account: " + user)
    return None

def DeleteAccount(user):
    """
    Delete the 'user'.
    Clear utmp first, to avoid error.
    Removes the /etc/sudoers.d/waagent file.
    """
    userentry = None
    try:
        userentry = pwd.getpwnam(user)
    except:
        pass
    if userentry == None:
        Error("DeleteAccount: " + user + " not found.")
        return
    uidmin = None
    try:
        uidmin = int(GetLineStartingWith("UID_MIN", "/etc/login.defs").split()[1])
    except:
        pass
    if uidmin == None:
        uidmin = 100
    if userentry[2] < uidmin:
        Error("DeleteAccount: " + user + " is a system user. Will not delete account.")
        return
    Run("> /var/run/utmp") #Delete utmp to prevent error if we are the 'user' deleted
    Run("userdel -f -r " + user)
    try:
        os.remove("/etc/sudoers.d/waagent")
    except:
        pass
    return

def IsInRangeInclusive(a, low, high):
    """
    Return True if 'a' in 'low' <= a >= 'high'
    """
    return (a >= low and a <= high)

def IsPrintable(ch):
    """
    Return True if character is displayable.
    """
    return IsInRangeInclusive(ch, Ord('A'), Ord('Z')) or IsInRangeInclusive(ch, Ord('a'), Ord('z')) or IsInRangeInclusive(ch, Ord('0'), Ord('9'))

def HexDump(buffer, size):
    """
    Return Hex formated dump of a 'buffer' of 'size'.
    """
    if size < 0:
        size = len(buffer)
    result = ""
    for i in range(0, size):
        if (i % 16) == 0:
            result += "%06X: " % i
        byte = buffer[i]
        if type(byte) == str:
            byte = ord(byte.decode('latin1'))
        result += "%02X " % byte
        if (i & 15) == 7:
            result += " "
        if ((i + 1) % 16) == 0 or (i + 1) == size:
            j = i
            while ((j + 1) % 16) != 0:
                result += "   "
                if (j & 7) == 7:
                    result += " "
                j += 1
            result += " "
            for j in range(i - (i % 16), i + 1):
                byte=buffer[j]
                if type(byte) == str:
                    byte = ord(byte.decode('latin1'))
                k = '.'
                if IsPrintable(byte):
                    k = chr(byte)
                result += k
            if (i + 1) != size:
                result += "\n"
    return result

def SimpleLog(file_path,message):
    if not file_path or len(message) < 1:
        return
    t = time.localtime()
    t = "%04u/%02u/%02u %02u:%02u:%02u " % (t.tm_year, t.tm_mon, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec)
    lines=re.sub(re.compile(r'^(.)',re.MULTILINE),t+r'\1',message)
    with open(file_path, "a") as F :
        lines = filter(lambda x : x in string.printable, lines)
        F.write(lines.encode('ascii','ignore') + "\n")

class Logger(object):
    """
    The Agent's logging assumptions are:
    For Log, and LogWithPrefix all messages are logged to the
    self.file_path and to the self.con_path.  Setting either path
    parameter to None skips that log.  If Verbose is enabled, messages
    calling the LogIfVerbose method will be logged to file_path yet
    not to con_path.  Error and Warn messages are normal log messages
    with the 'ERROR:' or 'WARNING:' prefix added.
    """

def __init__(self,filepath,conpath,verbose=False):
        """
        Construct an instance of Logger.
        """
        self.file_path=filepath
        self.con_path=conpath
        self.verbose=verbose
        
    def ThrottleLog(self,counter):
        """
        Log everything up to 10, every 10 up to 100, then every 100.
        """
        return (counter < 10) or ((counter < 100) and ((counter % 10) == 0)) or ((counter % 100) == 0)
    
    def LogToFile(self,message):
        """
        Write 'message' to logfile.
        """
        if self.file_path:
            try:
                with open(self.file_path, "a") as F :
                    message = filter(lambda x : x in string.printable, message)
                    F.write(message.encode('ascii','ignore') + "\n")
            except IOError, e:
                print e
                pass
            
    def LogToCon(self,message):
        """
        Write 'message' to /dev/console.
        This supports serial port logging if the /dev/console
        is redirected to ttys0 in kernel boot options.
        """
        if self.con_path:
            try:
                with open(self.con_path, "w") as C :
                    message = filter(lambda x : x in string.printable, message)
                    C.write(message.encode('ascii','ignore') + "\n")
            except IOError, e:
                pass
                
    def Log(self,message):
        """
        Standard Log function.
        Logs to self.file_path, and con_path
        """
        self.LogWithPrefix("", message)
    
    def LogWithPrefix(self,prefix, message):
        """
        Prefix each line of 'message' with current time+'prefix'.
        """
        t = time.localtime()
        t = "%04u/%02u/%02u %02u:%02u:%02u " % (t.tm_year, t.tm_mon, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec)
        t += prefix
        for line in message.split('\n'):
            line = t + line
            self.LogToFile(line)
            self.LogToCon(line)
            
    def NoLog(self,message):
        """
        Don't Log.
        """
        pass
    
    def LogIfVerbose(self,message):
        """
        Only log 'message' if global Verbose is True.
        """
        self.LogWithPrefixIfVerbose('',message)
    
    def LogWithPrefixIfVerbose(self,prefix, message):
        """
        Only log 'message' if global Verbose is True.
        Prefix each line of 'message' with current time+'prefix'.
        """
        if self.verbose == True:
            t = time.localtime()
            t = "%04u/%02u/%02u %02u:%02u:%02u " % (t.tm_year, t.tm_mon, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec)
            t += prefix
            for line in message.split('\n'):
                line = t + line
                self.LogToFile(line)
                self.LogToCon(line)
                
    def Warn(self,message):
        """
        Prepend the text "WARNING:" to the prefix for each line in 'message'.
        """
        self.LogWithPrefix("WARNING:", message)
    
    def Error(self,message):
        """
        Call ErrorWithPrefix(message).
        """
        ErrorWithPrefix("", message)
    
    def ErrorWithPrefix(self,prefix, message):
        """
        Prepend the text "ERROR:" to the prefix for each line in 'message'.
        Errors written to logfile, and /dev/console
        """
        self.LogWithPrefix("ERROR:", message)
    
def LoggerInit(log_file_path,log_con_path,verbose=False):
    """
    Create log object and export its methods to global scope.
    """
    global Log,LogWithPrefix,LogIfVerbose,LogWithPrefixIfVerbose,Error,ErrorWithPrefix,Warn,NoLog,ThrottleLog,myLogger
    l=Logger(log_file_path,log_con_path,verbose)
    Log,LogWithPrefix,LogIfVerbose,LogWithPrefixIfVerbose,Error,ErrorWithPrefix,Warn,NoLog,ThrottleLog,myLogger = l.Log,l.LogWithPrefix,l.LogIfVerbose,l.LogWithPrefixIfVerbose,l.Error,l.ErrorWithPrefix,l.Warn,l.NoLog,l.ThrottleLog,l

def Linux_ioctl_GetInterfaceMac(ifname):
    """
    Return the mac-address bound to the socket.
    """
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    info = fcntl.ioctl(s.fileno(), 0x8927,  struct.pack('256s', (ifname[:15]+('\0'*241)).encode('latin-1')))
    return ''.join(['%02X' % Ord(char) for char in info[18:24]])

def GetFirstActiveNetworkInterfaceNonLoopback():
    """
    Return the interface name, and ip addr of the
    first active non-loopback interface.
    """
    iface=''
    expected=16 # how many devices should I expect...
    is_64bits = sys.maxsize > 2**32
    struct_size=40 if is_64bits else 32 # for 64bit the size is 40 bytes, for 32bits it is 32 bytes.
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    buff=array.array('B', b'\0' * (expected*struct_size))
    retsize=(struct.unpack('iL', fcntl.ioctl(s.fileno(), 0x8912, struct.pack('iL',expected*struct_size,buff.buffer_info()[0]))))[0]
    if retsize == (expected*struct_size) :
        Warn('SIOCGIFCONF returned more than ' + str(expected) + ' up network interfaces.')
    s=buff.tostring()
    preferred_nic = Config.get("Network.Interface")
    for i in range(0,struct_size*expected,struct_size):
        iface=s[i:i+16].split(b'\0', 1)[0]
        if iface == b'lo':
            continue
        elif preferred_nic is None:
            break
        elif iface == preferred_nic:
            break
    return iface.decode('latin-1'), socket.inet_ntoa(s[i+20:i+24])

def GetIpv4Address():
    """
    Return the ip of the 
    first active non-loopback interface.
    """
    iface,addr=GetFirstActiveNetworkInterfaceNonLoopback()
    return addr

def HexStringToByteArray(a):
    """
    Return hex string packed into a binary struct.
    """
    b = b""
    for c in range(0, len(a) // 2):
        b += struct.pack("B", int(a[c * 2:c * 2 + 2], 16))
    return b

def GetMacAddress():
    """
    Convienience function, returns mac addr bound to
    first non-loobback interface.
    """
    ifname=''
    while len(ifname) < 2 :
        ifname=GetFirstActiveNetworkInterfaceNonLoopback()[0]
    a = Linux_ioctl_GetInterfaceMac(ifname)        
    return HexStringToByteArray(a)

def DeviceForIdePort(n):
    """
    Return device name attached to ide port 'n'.
    """
    if n > 3:
        return None
    g0 = "00000000"
    if n > 1:
        g0 = "00000001"
        n = n - 2
    device = None
    path = "/sys/bus/vmbus/devices/"
    for vmbus in os.listdir(path):
        guid = GetFileContents(path + vmbus + "/device_id").lstrip('{').split('-')
        if guid[0] == g0 and guid[1] == "000" + str(n):
            for root, dirs, files in os.walk(path + vmbus):
                if root.endswith("/block"):
                    device = dirs[0]
                    break
                else : #older distros
                    for d in dirs:
                        if ':' in d and "block" == d.split(':')[0]:
                            device = d.split(':')[1]
                            break
            break
    return device

class HttpResourceGoneError(Exception):
    pass

class Util(object):
    """
    Http communication class.
    Base of GoalState, and Agent classes.
    """
    RetryWaitingInterval=10

def __init__(self):
        self.Endpoint = None

def _ParseUrl(self, url):
        secure = False
        host = self.Endpoint
        path = url
        port = None
        
        #"http[s]://hostname[:port][/]"
        if url.startswith("http://"):
            url = url[7:]
            if "/" in url:
                host = url[0: url.index("/")]
                path = url[url.index("/"):]
            else:
                host = url
                path = "/"
        elif url.startswith("https://"):
            secure = True
            url = url[8:]
            if "/" in url:
                host = url[0: url.index("/")]
                path = url[url.index("/"):]
            else:
                host = url
                path = "/"

if host is None:
            raise ValueError("Host is invalid:{0}".format(url))
        
        if(":" in host):
            pos = host.rfind(":")
            port = int(host[pos + 1:])
            host = host[0:pos]
        
        return host, port, secure, path

def GetHttpProxy(self, secure):
        """
        Get http_proxy and https_proxy from environment variables.
        Username and password is not supported now.
        """
        host = Config.get("HttpProxy.Host")
        port = Config.get("HttpProxy.Port")
        return (host, port)

def _HttpRequest(self, method, host, path, port=None, data=None, secure=False, 
                     headers=None, proxyHost=None, proxyPort=None):
        resp = None
        conn = None
        try:
            if secure:
                port = 443 if port is None else port
                if proxyHost is not None and proxyPort is not None:
                    conn = httplib.HTTPSConnection(proxyHost, proxyPort, timeout=10)
                    conn.set_tunnel(host, port)
                    #If proxy is used, full url is needed.
                    path = "https://{0}:{1}{2}".format(host, port, path)
                else:
                    conn = httplib.HTTPSConnection(host, port, timeout=10)
            else:
                port = 80 if port is None else port
                if proxyHost is not None and proxyPort is not None:
                    conn = httplib.HTTPConnection(proxyHost, proxyPort, timeout=10)
                    #If proxy is used, full url is needed.
                    path = "http://{0}:{1}{2}".format(host, port, path)
                else:
                    conn = httplib.HTTPConnection(host, port, timeout=10)
            if headers == None:
                conn.request(method, path, data)
            else:
                conn.request(method, path, data, headers)
            resp = conn.getresponse()
        except httplib.HTTPException, e:
            Error('HTTPException {0}, args:{1}'.format(e, repr(e.args)))
        except IOError, e:
            Error('Socket IOError {0}, args:{1}'.format(e, repr(e.args)))
        return resp

def HttpRequest(self, method, url, data=None, 
                    headers=None, maxRetry=3, chkProxy=False):
        """
        Sending http request to server
        On error, sleep 10 and maxRetry times.
        Return the output buffer or None.
        """
        LogIfVerbose("HTTP Req: {0} {1}".format(method, url))
        LogIfVerbose("HTTP Req: Data={0}".format(data))
        LogIfVerbose("HTTP Req: Header={0}".format(headers))
        try:
            host, port, secure, path = self._ParseUrl(url)
        except ValueError, e:
            Error("Failed to parse url:{0}".format(url))
            return None

#Check proxy
        proxyHost, proxyPort = (None, None)
        if chkProxy:
            proxyHost, proxyPort = self.GetHttpProxy(secure)

#If httplib module is not built with ssl support. Fallback to http
        if secure and not hasattr(httplib, "HTTPSConnection"):
            Warn("httplib is not built with ssl support")
            secure = False
            proxyHost, proxyPort = self.GetHttpProxy(secure)
        
        #If httplib module doesn't support https tunnelling. Fallback to http
        if secure and \
                proxyHost is not None and \
                proxyPort is not None and \
                not hasattr(httplib.HTTPSConnection, "set_tunnel"):
            Warn("httplib doesn't support https tunnelling(new in python 2.7)")
            secure = False
            proxyHost, proxyPort = self.GetHttpProxy(secure)

resp = self._HttpRequest(method, host, path, port=port, data=data, 
                                 secure=secure, headers=headers,
                                 proxyHost=proxyHost, proxyPort=proxyPort)
        for retry in range(0, maxRetry):
            if resp is not None and \
                   (resp.status == httplib.OK or \
                    resp.status == httplib.CREATED or \
                    resp.status == httplib.ACCEPTED):
                return resp;

if resp is not None and resp.status == httplib.GONE:
                raise HttpResourceGoneError("Http resource gone.")

Error("Retry={0}".format(retry))
            Error("HTTP Req: {0} {1}".format(method, url))
            Error("HTTP Req: Data={0}".format(data))
            Error("HTTP Req: Header={0}".format(headers))
            if resp is None:
                Error("HTTP Err: response is empty.".format(retry))
            else:
                Error("HTTP Err: Status={0}".format(resp.status))
                Error("HTTP Err: Reason={0}".format(resp.reason))
                Error("HTTP Err: Header={0}".format(resp.getheaders()))
                Error("HTTP Err: Body={0}".format(resp.read()))

time.sleep(self.__class__.RetryWaitingInterval)
            resp = self._HttpRequest(method, host, path, port=port, data=data, 
                                     secure=secure, headers=headers,
                                     proxyHost=proxyHost, proxyPort=proxyPort)

return None

def HttpGet(self, url, headers=None, maxRetry=3, chkProxy=False):
        return self.HttpRequest("GET", url, headers=headers, 
                                maxRetry=maxRetry, chkProxy=chkProxy)
        
    def HttpHead(self, url, headers=None, maxRetry=3, chkProxy=False):
        return self.HttpRequest("HEAD", url, headers=headers, 
                                maxRetry=maxRetry, chkProxy=chkProxy)
        
    def HttpPost(self, url, data, headers=None, maxRetry=3, chkProxy=False):
        return self.HttpRequest("POST", url, data=data, headers=headers, 
                                maxRetry=maxRetry, chkProxy=chkProxy)

def HttpPut(self, url, data, headers=None, maxRetry=3, chkProxy=False):
        return self.HttpRequest("PUT", url, data=data, headers=headers, 
                                maxRetry=maxRetry, chkProxy=chkProxy)

def HttpDelete(self, url, headers=None, maxRetry=3, chkProxy=False):
        return self.HttpRequest("DELETE", url, headers=headers, 
                                maxRetry=maxRetry, chkProxy=chkProxy)
    
    def HttpGetWithoutHeaders(self, url, maxRetry=3, chkProxy=False):
        """
        Return data from an HTTP get on 'url'.
        """
        resp = self.HttpGet(url, headers=None, maxRetry=maxRetry, 
                            chkProxy=chkProxy)
        return resp.read() if resp is not None else None

def HttpGetWithHeaders(self, url, maxRetry=3, chkProxy=False):
        """
        Return data from an HTTP get on 'url' with
        x-ms-agent-name and x-ms-version
        headers.
        """
        resp = self.HttpGet(url, headers={
            "x-ms-agent-name": GuestAgentName, 
            "x-ms-version": ProtocolVersion
        }, maxRetry=maxRetry, chkProxy=chkProxy)
        return resp.read() if resp is not None else None

def HttpSecureGetWithHeaders(self, url, transportCert, maxRetry=3, 
                                 chkProxy=False):
        """
        Return output of get using ssl cert.
        """
        resp = self.HttpGet(url, headers={
            "x-ms-agent-name": GuestAgentName,
            "x-ms-version": ProtocolVersion,
            "x-ms-cipher-name": "DES_EDE3_CBC",
            "x-ms-guest-agent-public-x509-cert": transportCert
        }, maxRetry=maxRetry, chkProxy=chkProxy)
        return resp.read() if resp is not None else None

def HttpPostWithHeaders(self, url, data, maxRetry=3, chkProxy=False):
        headers = {
            "x-ms-agent-name": GuestAgentName,
            "Content-Type": "text/xml; charset=utf-8",
            "x-ms-version": ProtocolVersion
        }
        try:
            return self.HttpPost(url, data=data, headers=headers, 
                                 maxRetry=maxRetry, chkProxy=chkProxy)
        except HttpResourceGoneError as e:
            Error("Failed to post: {0} {1}".format(url, e))
            return None

__StorageVersion="2014-02-14"

def GetBlobType(url):
    restutil = Util()
    #Check blob type
    LogIfVerbose("Check blob type.")
    timestamp = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
    blobPropResp = restutil.HttpHead(url, {
        "x-ms-date" :  timestamp,
        'x-ms-version' : __StorageVersion
    }, chkProxy=True);
    blobType = None
    if blobPropResp is None:
        Error("Can't get status blob type.")
        return None
    blobType = blobPropResp.getheader("x-ms-blob-type")
    LogIfVerbose("Blob type={0}".format(blobType))
    return blobType

def PutBlockBlob(url, data):
    restutil = Util()
    LogIfVerbose("Upload block blob")
    timestamp = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
    ret = restutil.HttpPut(url, data, {
        "x-ms-date" :  timestamp,
        "x-ms-blob-type" : "BlockBlob",
        "Content-Length": str(len(data)),
        "x-ms-version" : __StorageVersion
    }, chkProxy=True)
    if ret is None:
        Error("Failed to upload block blob for status.")
        return -1
    return 0

def PutPageBlob(url, data):
    restutil = Util()
    LogIfVerbose("Replace old page blob")
    timestamp = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
    #Align to 512 bytes
    pageBlobSize = ((len(data) + 511) / 512) * 512
    ret = restutil.HttpPut(url, "", {
        "x-ms-date" :  timestamp,
        "x-ms-blob-type" : "PageBlob",
        "Content-Length": "0",
        "x-ms-blob-content-length" : str(pageBlobSize),
        "x-ms-version" : __StorageVersion
    }, chkProxy=True)
    if ret is None:
        Error("Failed to clean up page blob for status")
        return -1
        
    if url.index('?') < 0:
        url = "{0}?comp=page".format(url)
    else:
        url = "{0}&comp=page".format(url)
   
    LogIfVerbose("Upload page blob")
    pageMax = 4 * 1024 * 1024 #Max page size: 4MB
    start = 0
    end = 0
    while end < len(data):
        end = min(len(data), start + pageMax)
        contentSize = end - start
        #Align to 512 bytes
        pageEnd = ((end + 511) / 512) * 512
        bufSize = pageEnd - start
        buf = bytearray(bufSize)
        buf[0 : contentSize] = data[start : end]
        ret = restutil.HttpPut(url, buffer(buf), {
            "x-ms-date" :  timestamp,
            "x-ms-range" : "bytes={0}-{1}".format(start, pageEnd - 1),
            "x-ms-page-write" : "update",
            "x-ms-version" : __StorageVersion,
            "Content-Length": str(pageEnd - start)
        }, chkProxy=True)
        if ret is None:
            Error("Failed to upload page blob for status")
            return -1
        start = end
    return 0

def UploadStatusBlob(url, data):
    LogIfVerbose("Upload status blob")
    LogIfVerbose("Status={0}".format(data))
    blobType = GetBlobType(url)

if blobType == "BlockBlob":
        return PutBlockBlob(url, data)    
    elif blobType == "PageBlob":
        return PutPageBlob(url, data)    
    else:
        Error("Unknown blob type: {0}".format(blobType))
        return -1

class TCPHandler(SocketServer.BaseRequestHandler):
    """
    Callback object for LoadBalancerProbeServer.
    Recv and send LB probe messages.
    """
    def __init__(self,lb_probe):
        super(TCPHandler,self).__init__()
        self.lb_probe=lb_probe
        
    def GetHttpDateTimeNow(self):
        """
        Return formatted gmtime "Date: Fri, 25 Mar 2011 04:53:10 GMT"
        """
        return time.strftime("%a, %d %b %Y %H:%M:%S GMT", time.gmtime())

def handle(self):
        """
        Log LB probe messages, read the socket buffer,
        send LB probe response back to server.
        """
        self.lb_probe.ProbeCounter = (self.lb_probe.ProbeCounter + 1) % 1000000
        log = [NoLog, LogIfVerbose][ThrottleLog(self.lb_probe.ProbeCounter)]
        strCounter = str(self.lb_probe.ProbeCounter)
        if self.lb_probe.ProbeCounter == 1:
            Log("Receiving LB probes.")
        log("Received LB probe # " + strCounter)
        self.request.recv(1024)
        self.request.send("HTTP/1.1 200 OK\r\nContent-Length: 2\r\nContent-Type: text/html\r\nDate: " + self.GetHttpDateTimeNow() + "\r\n\r\nOK")
            
class LoadBalancerProbeServer(object):
    """
    Threaded object to receive and send LB probe messages.
    Load Balancer messages but be recv'd by
    the load balancing server, or this node may be shut-down.
    """
    def __init__(self, port):
        self.ProbeCounter = 0
        self.server = SocketServer.TCPServer((self.get_ip(), port), TCPHandler)
        self.server_thread = threading.Thread(target = self.server.serve_forever)
        self.server_thread.setDaemon(True)
        self.server_thread.start()
        
    def shutdown(self):
        self.server.shutdown()

def get_ip(self):
        for retry in range(1,6):
            ip = MyDistro.GetIpv4Address()
            if ip == None :
                Log("LoadBalancerProbeServer: GetIpv4Address() returned None, sleeping 10 before retry " + str(retry+1) )
                time.sleep(10)
            else:
                return ip

class ConfigurationProvider(object):
    """
    Parse amd store key:values in waagent.conf
    """
    def __init__(self, walaConfigFile):
        self.values = dict()
        if 'MyDistro' not in globals():
            global MyDistro
            MyDistro = GetMyDistro()
        if walaConfigFile is None:
            walaConfigFile = MyDistro.getConfigurationPath()
        if os.path.isfile(walaConfigFile) == False:
            raise Exception("Missing configuration in {0}".format(walaConfigFile))
        try:
            for line in GetFileContents(walaConfigFile).split('\n'):
                if not line.startswith("#") and "=" in line:
                    parts = line.split()[0].split('=')
                    value = parts[1].strip("\" ")
                    if value != "None":
                        self.values[parts[0]] = value
                    else:
                        self.values[parts[0]] = None
        except:
            Error("Unable to parse {0}".format(walaConfigFile))
            raise
        return

def get(self, key):
        return self.values.get(key)

class EnvMonitor(object):
    """
    Montor changes to dhcp and hostname.
    If dhcp clinet process re-start has occurred, reset routes, dhcp with fabric.
    """
    def __init__(self):
        self.shutdown = False
        self.HostName = socket.gethostname()
        self.server_thread = threading.Thread(target = self.monitor)
        self.server_thread.setDaemon(True)
        self.server_thread.start()
        self.published = False

def monitor(self):
        """
        Monitor dhcp client pid and hostname.
        If dhcp clinet process re-start has occurred, reset routes, dhcp with fabric.
        """
        publish = Config.get("Provisioning.MonitorHostName")
        dhcpcmd = MyDistro.getpidcmd+ ' ' + MyDistro.getDhcpClientName()
        dhcppid = RunGetOutput(dhcpcmd)[1]
        while not self.shutdown:
            for a in RulesFiles:
                if os.path.isfile(a):
                    if os.path.isfile(GetLastPathElement(a)):
                        os.remove(GetLastPathElement(a))
                    shutil.move(a, ".")
                    Log("EnvMonitor: Moved " + a + " -> " + LibDir)
            MyDistro.setScsiDiskTimeout()
            if publish != None and publish.lower().startswith("y"):
                try:
                    if socket.gethostname() != self.HostName:
                        Log("EnvMonitor: Detected host name change: " + self.HostName + " -> " + socket.gethostname())
                        self.HostName = socket.gethostname()
                        WaAgent.UpdateAndPublishHostName(self.HostName)
                        dhcppid = RunGetOutput(dhcpcmd)[1]
                        self.published = True
                except:
                    pass
            else:
                self.published = True
            pid = ""
            if not os.path.isdir("/proc/" + dhcppid.strip()):
                pid = RunGetOutput(dhcpcmd)[1]
            if pid != "" and pid != dhcppid:
                Log("EnvMonitor: Detected dhcp client restart. Restoring routing table.")
                WaAgent.RestoreRoutes()
                dhcppid = pid
            for child in Children:
                if child.poll() != None:
                    Children.remove(child)
            time.sleep(5)

def SetHostName(self, name):
        """
        Generic call to MyDistro.setHostname(name).
        Complian to Log on error.
        """
        if socket.gethostname() == name:
            self.published = True
        elif MyDistro.setHostname(name):
            Error("Error: SetHostName: Cannot set hostname to " + name)
            return ("Error: SetHostName: Cannot set hostname to " + name)

def IsHostnamePublished(self):
        """
        Return self.published  
        """
        return self.published

def ShutdownService(self):
        """
        Stop server comminucation and join the thread to main thread.
        """
        self.shutdown = True
        self.server_thread.join()

class Certificates(object):
    """
    Object containing certificates of host and provisioned user.
    Parses and splits certificates into files.
    """
    #     <CertificateFile xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="certificates10.xsd">
    #     <Version>2010-12-15</Version>
    #     <Incarnation>2</Incarnation>
    #     <Format>Pkcs7BlobWithPfxContents</Format>
    #     <Data>MIILTAY...
    #     </Data>
    #     </CertificateFile>

def __init__(self):
        self.reinitialize()

def reinitialize(self):
        """
        Reset the Role, Incarnation
        """
        self.Incarnation = None
        self.Role = None

def Parse(self, xmlText):
        """
        Parse multiple certificates into seperate files.
        """
        self.reinitialize()
        SetFileContents("Certificates.xml", xmlText)
        dom = xml.dom.minidom.parseString(xmlText)
        for a in [ "CertificateFile", "Version", "Incarnation",
                   "Format", "Data", ]:
            if not dom.getElementsByTagName(a):
                Error("Certificates.Parse: Missing " + a)
                return None
        node = dom.childNodes[0]
        if node.localName != "CertificateFile":
            Error("Certificates.Parse: root not CertificateFile")
            return None
        SetFileContents("Certificates.p7m",
            "MIME-Version: 1.0\n"
            + "Content-Disposition: attachment; filename=\"Certificates.p7m\"\n"
            + "Content-Type: application/x-pkcs7-mime; name=\"Certificates.p7m\"\n"
            + "Content-Transfer-Encoding: base64\n\n"
            + GetNodeTextData(dom.getElementsByTagName("Data")[0]))
        if Run(Openssl + " cms -decrypt -in Certificates.p7m -inkey TransportPrivate.pem -recip TransportCert.pem | " + Openssl + " pkcs12 -nodes -password pass: -out Certificates.pem"):
            Error("Certificates.Parse: Failed to extract certificates from CMS message.")
            return self
        # There may be multiple certificates in this package. Split them.
        file = open("Certificates.pem")
        pindex = 1
        cindex = 1
        output = open("temp.pem", "w")
        for line in file.readlines():
            output.write(line)
            if re.match(r'[-]+END .*?(KEY|CERTIFICATE)[-]+$',line):
                output.close()
                if re.match(r'[-]+END .*?KEY[-]+$',line):
                    os.rename("temp.pem", str(pindex) + ".prv")
                    pindex += 1
                else:
                    os.rename("temp.pem", str(cindex) + ".crt")
                    cindex += 1
                output = open("temp.pem", "w")
        output.close()
        os.remove("temp.pem")
        keys = dict()
        index = 1
        filename = str(index) + ".crt"
        while os.path.isfile(filename):
            thumbprint = (RunGetOutput(Openssl + " x509 -in " + filename + " -fingerprint -noout")[1]).rstrip().split('=')[1].replace(':', '').upper()
            pubkey=RunGetOutput(Openssl + " x509 -in " + filename + " -pubkey -noout")[1]
            keys[pubkey] = thumbprint
            os.rename(filename, thumbprint + ".crt")
            os.chmod(thumbprint + ".crt", 0600)
            MyDistro.setSelinuxContext(thumbprint + '.crt','unconfined_u:object_r:ssh_home_t:s0')
            index += 1
            filename = str(index) + ".crt"
        index = 1
        filename = str(index) + ".prv"
        while os.path.isfile(filename):
            pubkey = RunGetOutput(Openssl + " rsa -in " + filename + " -pubout 2> /dev/null ")[1]
            os.rename(filename, keys[pubkey] + ".prv")
            os.chmod(keys[pubkey] + ".prv", 0600)
            MyDistro.setSelinuxContext( keys[pubkey] + '.prv','unconfined_u:object_r:ssh_home_t:s0')
            index += 1
            filename = str(index) + ".prv"
        return self

class SharedConfig(object):
    """
    Parse role endpoint server and goal state config.
    """
    #
    # <SharedConfig version="1.0.0.0" goalStateIncarnation="1">
    #   <Deployment name="db00a7755a5e4e8a8fe4b19bc3b330c3" guid="{ce5a036f-5c93-40e7-8adf-2613631008ab}" incarnation="2">
    #     <Service name="MyVMRoleService" guid="{00000000-0000-0000-0000-000000000000}" />
    #     <ServiceInstance name="db00a7755a5e4e8a8fe4b19bc3b330c3.1" guid="{d113f4d7-9ead-4e73-b715-b724b5b7842c}" />
    #   </Deployment>
    #   <Incarnation number="1" instance="MachineRole_IN_0" guid="{a0faca35-52e5-4ec7-8fd1-63d2bc107d9b}" />
    #   <Role guid="{73d95f1c-6472-e58e-7a1a-523554e11d46}" name="MachineRole" settleTimeSeconds="10" />
    #   <LoadBalancerSettings timeoutSeconds="0" waitLoadBalancerProbeCount="8">
    #     <Probes>
    #       <Probe name="MachineRole" />
    #       <Probe name="55B17C5E41A1E1E8FA991CF80FAC8E55" />
    #       <Probe name="3EA4DBC19418F0A766A4C19D431FA45F" />
    #     </Probes>
    #   </LoadBalancerSettings>
    #   <OutputEndpoints>
    #     <Endpoint name="MachineRole:Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp" type="SFS">
    #       <Target instance="MachineRole_IN_0" endpoint="Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp" />
    #     </Endpoint>
    #   </OutputEndpoints>
    #   <Instances>
    #     <Instance id="MachineRole_IN_0" address="10.115.153.75">
    #       <FaultDomains randomId="0" updateId="0" updateCount="0" />
    #       <InputEndpoints>
    #         <Endpoint name="a" address="10.115.153.75:80" protocol="http" isPublic="true" loadBalancedPublicAddress="70.37.106.197:80" enableDirectServerReturn="false" isDirectAddress="false" disableStealthMode="false">
    #           <LocalPorts>
    #             <LocalPortRange from="80" to="80" />
    #           </LocalPorts>
    #         </Endpoint>
    #         <Endpoint name="Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp" address="10.115.153.75:3389" protocol="tcp" isPublic="false" enableDirectServerReturn="false" isDirectAddress="false" disableStealthMode="false">
    #           <LocalPorts>
    #             <LocalPortRange from="3389" to="3389" />
    #           </LocalPorts>
    #         </Endpoint>
    #         <Endpoint name="Microsoft.WindowsAzure.Plugins.RemoteForwarder.RdpInput" address="10.115.153.75:20000" protocol="tcp" isPublic="true" loadBalancedPublicAddress="70.37.106.197:3389" enableDirectServerReturn="false" isDirectAddress="false" disableStealthMode="false">
    #           <LocalPorts>
    #             <LocalPortRange from="20000" to="20000" />
    #           </LocalPorts>
    #         </Endpoint>
    #       </InputEndpoints>
    #     </Instance>
    #   </Instances>
    # </SharedConfig>
    #
    def __init__(self):
        self.reinitialize()

def reinitialize(self):
        """
        Reset members.
        """
        self.RdmaMacAddress = None
        self.RdmaIPv4Address = None
        self.xmlText = None

def Parse(self, xmlText):
        """
        Parse and write configuration to file SharedConfig.xml.
        """
        LogIfVerbose(xmlText)
        self.reinitialize()
        self.xmlText = xmlText
        dom = xml.dom.minidom.parseString(xmlText)
        for a in [ "SharedConfig", "Deployment", "Service",
                   "ServiceInstance", "Incarnation", "Role", ]:
            if not dom.getElementsByTagName(a):
                Error("SharedConfig.Parse: Missing " + a)

node = dom.childNodes[0]
        if node.localName != "SharedConfig":
            Error("SharedConfig.Parse: root not SharedConfig")

nodes = dom.getElementsByTagName("Instance")
        if nodes is not None and len(nodes) != 0:
            node = nodes[0]
            if node.hasAttribute("rdmaMacAddress"):
                addr = node.getAttribute("rdmaMacAddress")
                self.RdmaMacAddress = addr[0:2]
                for i in range(1, 6):
                    self.RdmaMacAddress += ":" + addr[2 * i : 2 *i + 2]
            if node.hasAttribute("rdmaIPv4Address"):
                self.RdmaIPv4Address = node.getAttribute("rdmaIPv4Address")
        return self
    
    def Save(self):
        LogIfVerbose("Save SharedConfig.xml")
        SetFileContents("SharedConfig.xml", self.xmlText)

def InvokeTopologyConsumer(self):
        program = Config.get("Role.TopologyConsumer")
        if program != None:
            try:
                Children.append(subprocess.Popen([program, LibDir + "/SharedConfig.xml"]))
            except OSError, e :
                ErrorWithPrefix('Agent.Run','Exception: '+ str(e) +' occured launching ' + program )

def Process(self):
        global rdma_configured
        if not rdma_configured and self.RdmaMacAddress is not None and self.RdmaIPv4Address is not None:
            handler = RdmaHandler(self.RdmaMacAddress, self.RdmaIPv4Address)
            handler.start()
            rdma_configured = True
        self.InvokeTopologyConsumer()

rdma_configured = False

class RdmaError(Exception):
    pass

class RdmaHandler(object):
    """
    Handle rdma configuration.
    """

def __init__(self, mac, ip_addr, dev="/dev/hvnd_rdma",
                 dat_conf_files=['/etc/dat.conf', '/etc/rdma/dat.conf',
                                 '/usr/local/etc/dat.conf']):
        self.mac = mac
        self.ip_addr = ip_addr
        self.dev = dev
        self.dat_conf_files = dat_conf_files
        self.data = ('rdmaMacAddress="{0}" rdmaIPv4Address="{1}"'
                     '').format(self.mac, self.ip_addr)

def start(self):
        """
        Start a new thread to process rdma
        """
        threading.Thread(target=self.process).start()

def process(self):
        try:
            self.set_dat_conf()
            self.set_rdma_dev()
            self.set_rdma_ip()
        except RdmaError as e:
            Error("Failed to config rdma device: {0}".format(e))

def set_dat_conf(self):
        """
        Agent needs to search all possible locations for dat.conf
        """
        Log("Set dat.conf")
        for dat_conf_file in self.dat_conf_files:
            if not os.path.isfile(dat_conf_file):
                continue
            try:
                self.write_dat_conf(dat_conf_file)
            except IOError as e:
                raise RdmaError("Failed to write to dat.conf: {0}".format(e))

def write_dat_conf(self, dat_conf_file):
        Log("Write config to {0}".format(dat_conf_file))
        old = ("ofa-v2-ib0 u2.0 nonthreadsafe default libdaplofa.so.2 "
               "dapl.2.0 \"\S+ 0\"")
        new = ("ofa-v2-ib0 u2.0 nonthreadsafe default libdaplofa.so.2 "
               "dapl.2.0 \"{0} 0\"").format(self.ip_addr)
        lines = GetFileContents(dat_conf_file)
        lines = re.sub(old, new, lines)
        SetFileContents(dat_conf_file, lines)

def set_rdma_dev(self):
        """
        Write config string to /dev/hvnd_rdma
        """
        Log("Set /dev/hvnd_rdma")
        self.wait_rdma_dev()
        self.write_rdma_dev_conf()

def write_rdma_dev_conf(self):
        Log("Write rdma config to {0}: {1}".format(self.dev, self.data))
        try:
            with open(self.dev, "w") as c:
                c.write(self.data)
        except IOError, e:
            raise RdmaError("Error writing {0}, {1}".format(self.dev, e))

def wait_rdma_dev(self):
        Log("Wait for /dev/hvnd_rdma")
        retry = 0
        while retry < 120:
            if os.path.exists(self.dev):
                return
            time.sleep(1)
            retry += 1
        raise RdmaError("The device doesn't show up in 120 seconds")

def set_rdma_ip(self):
        Log("Set ip addr for rdma")
        try:
            if_name = MyDistro.getInterfaceNameByMac(self.mac)
            #Azure is using 12 bits network mask for infiniband.
            MyDistro.configIpV4(if_name, self.ip_addr, 12)
        except Exception as e:
            raise RdmaError("Failed to config rdma device: {0}".format(e))

class ExtensionsConfig(object):
    """
    Parse ExtensionsConfig, downloading and unpacking them to /var/lib/waagent.
    Install if <enabled>true</enabled>, remove if it is set to false.
    """
    #<?xml version="1.0" encoding="utf-8"?>
    #<Extensions version="1.0.0.0" goalStateIncarnation="6"><Plugins>
    #  <Plugin name="OSTCExtensions.ExampleHandlerLinux" version="1.5"
    #location="http://previewusnorthcache.blob.core.test-cint.azure-test.net/d84b216d00bf4d96982be531539e1513/OSTCExtensions_ExampleHandlerLinux_usnorth_manifest.xml"
    #config="" state="enabled" autoUpgrade="false" runAsStartupTask="false" isJson="true" />
    #</Plugins>
    #<PluginSettings>
    #  <Plugin name="OSTCExtensions.ExampleHandlerLinux" version="1.5">
    #    <RuntimeSettings seqNo="2">{"runtimeSettings":[{"handlerSettings":{"protectedSettingsCertThumbprint":"1BE9A13AA1321C7C515EF109746998BAB6D86FD1",
    #"protectedSettings":"MIIByAYJKoZIhvcNAQcDoIIBuTCCAbUCAQAxggFxMIIBbQIBADBVMEExPzA9BgoJkiaJk/IsZAEZFi9XaW5kb3dzIEF6dXJlIFNlcnZpY2UgTWFuYWdlbWVudCBmb3IgR
    #Xh0ZW5zaW9ucwIQZi7dw+nhc6VHQTQpCiiV2zANBgkqhkiG9w0BAQEFAASCAQCKr09QKMGhwYe+O4/a8td+vpB4eTR+BQso84cV5KCAnD6iUIMcSYTrn9aveY6v6ykRLEw8GRKfri2d6
    #tvVDggUrBqDwIgzejGTlCstcMJItWa8Je8gHZVSDfoN80AEOTws9Fp+wNXAbSuMJNb8EnpkpvigAWU2v6pGLEFvSKC0MCjDTkjpjqciGMcbe/r85RG3Zo21HLl0xNOpjDs/qqikc/ri43Y76E/X
    #v1vBSHEGMFprPy/Hwo3PqZCnulcbVzNnaXN3qi/kxV897xGMPPC3IrO7Nc++AT9qRLFI0841JLcLTlnoVG1okPzK9w6ttksDQmKBSHt3mfYV+skqs+EOMDsGCSqGSIb3DQEHATAUBggqh
    #kiG9w0DBwQITgu0Nu3iFPuAGD6/QzKdtrnCI5425fIUy7LtpXJGmpWDUA==","publicSettings":{"port":"3000"}}}]}</RuntimeSettings>
    #  </Plugin>
    #</PluginSettings>
    #<StatusUploadBlob>https://ostcextensions.blob.core.test-cint.azure-test.net/vhds/eg-plugin7-vm.eg-plugin7-vm.eg-plugin7-vm.status?sr=b&amp;sp=rw&amp;
    #se=9999-01-01&amp;sk=key1&amp;sv=2012-02-12&amp;sig=wRUIDN1x2GC06FWaetBP9sjjifOWvRzS2y2XBB4qoBU%3D</StatusUploadBlob></Extensions>

def __init__(self):
        self.reinitialize()

def reinitialize(self):
        """
        Reset members.
        """
        self.Extensions = None
        self.Plugins = None
        self.Util = None
        
    def Parse(self, xmlText):
        """
        Write configuration to file ExtensionsConfig.xml.
        Log plugin specific activity to /var/log/azure/<Publisher>.<PluginName>/<Version>/CommandExecution.log.
        If state is enabled:
            if the plugin is installed:
                if the new plugin's version is higher
                if DisallowMajorVersionUpgrade is false or if true, the version is a minor version do upgrade:
                    download the new archive
                    do the updateCommand.
                    disable the old plugin and remove
                    enable the new plugin
                if the new plugin's version is the same or lower:
                    create the new .settings file from the configuration received
                    do the enableCommand
            if the plugin is not installed:
                download/unpack archive and call the installCommand/Enable
        if state is disabled:
            call disableCommand
        if state is uninstall:
            call uninstallCommand
            remove old plugin directory.
        """
        self.reinitialize()
        self.Util=Util()
        dom = xml.dom.minidom.parseString(xmlText)
        LogIfVerbose(xmlText)
        self.plugin_log_dir='/var/log/azure'
        if not os.path.exists(self.plugin_log_dir):
            os.mkdir(self.plugin_log_dir)
        try:
            self.Extensions=dom.getElementsByTagName("Extensions")
            pg = dom.getElementsByTagName("Plugins")
            if len(pg) > 0:
                self.Plugins = pg[0].getElementsByTagName("Plugin")
            else:
                self.Plugins = []
            incarnation=self.Extensions[0].getAttribute("goalStateIncarnation")
            SetFileContents('ExtensionsConfig.'+incarnation+'.xml', xmlText)
        except Exception, e:
            Error('ERROR:  Error parsing ExtensionsConfig: {0}.'.format(e))
            return None
        for p in self.Plugins:
            if len(p.getAttribute("location"))<1:  # this plugin is inside the PluginSettings
                continue
            p.setAttribute('restricted','false')
            previous_version = None
            version=p.getAttribute("version")
            name=p.getAttribute("name")
            plog_dir=self.plugin_log_dir+'/'+name +'/'+ version
            if not os.path.exists(plog_dir):
                os.makedirs(plog_dir)
            p.plugin_log=plog_dir+'/CommandExecution.log'
            handler=name + '-' + version
            if p.getAttribute("isJson") != 'true':
                Error("Plugin " + name+" version: " +version+" is not a JSON Extension.  Skipping.")
                continue
            Log("Found Plugin: " + name + ' version: ' + version)
            if p.getAttribute("state") == 'disabled' or p.getAttribute("state") == 'uninstall': 
                #disable 
                zip_dir=LibDir+"/" + name + '-' + version
                mfile=None
                for root, dirs, files in os.walk(zip_dir):
                    for f in files:
                        if f in ('HandlerManifest.json'):
                            mfile=os.path.join(root,f)
                    if mfile != None:
                        break
                if mfile == None :
                    Error('HandlerManifest.json not found.')
                    continue
                manifest = GetFileContents(mfile)
                p.setAttribute('manifestdata',manifest)
                if self.launchCommand(p.plugin_log,name,version,'disableCommand') == None :
                    self.SetHandlerState(handler, 'Enabled')
                    Error('Unable to disable '+name)
                    SimpleLog(p.plugin_log,'ERROR: Unable to disable '+name)
                else :
                    self.SetHandlerState(handler, 'Disabled')
                    Log(name+' is disabled')
                    SimpleLog(p.plugin_log,name+' is disabled')

# uninstall if needed
                if p.getAttribute("state") == 'uninstall':
                    if self.launchCommand(p.plugin_log,name,version,'uninstallCommand') == None :
                        self.SetHandlerState(handler, 'Installed')
                        Error('Unable to uninstall '+name)
                        SimpleLog(p.plugin_log,'Unable to uninstall '+name)
                    else :
                        self.SetHandlerState(handler, 'NotInstalled')
                        Log(name+' uninstallCommand completed .')
                    # remove the plugin
                    Run('rm -rf ' + LibDir + '/' + name +'-'+ version + '*')
                    Log(name +'-'+ version + ' extension files deleted.')
                    SimpleLog(p.plugin_log,name +'-'+ version + ' extension files deleted.')

continue    
            # state is enabled
            # if the same plugin exists and the version is newer or
            # does not exist then download and unzip the new plugin
            plg_dir=None

latest_version_installed = LooseVersion("0.0")
            for item in os.listdir(LibDir):
                itemPath = os.path.join(LibDir, item)
                if os.path.isdir(itemPath) and name in item:
                    try:
                        #Split plugin dir name with '-' to get intalled plugin name and version
                        sperator = item.rfind('-')
                        if sperator < 0:
                            continue
                        installed_plg_name = item[0:sperator]
                        installed_plg_version = LooseVersion(item[sperator + 1:])

#Check installed plugin name and compare installed version to get the latest version installed
                        if installed_plg_name == name and installed_plg_version > latest_version_installed:
                            plg_dir = itemPath
                            previous_version = str(installed_plg_version)
                            latest_version_installed = installed_plg_version
                    except Exception as e:
                        Warn("Invalid plugin dir name: {0} {1}".format(item, e))
                        continue

if plg_dir == None or LooseVersion(version) > LooseVersion(previous_version) :
                location=p.getAttribute("location")
                Log("Downloading plugin manifest: " + name + " from " + location)
                SimpleLog(p.plugin_log,"Downloading plugin manifest: " + name + " from " + location)

self.Util.Endpoint=location.split('/')[2]
                Log("Plugin server is: " +  self.Util.Endpoint)
                SimpleLog(p.plugin_log,"Plugin server is: " +  self.Util.Endpoint)

manifest=self.Util.HttpGetWithoutHeaders(location, chkProxy=True)
                if manifest == None:
                    Error("Unable to download plugin manifest" + name + " from primary location.  Attempting with failover location.")
                    SimpleLog(p.plugin_log,"Unable to download plugin manifest" + name + " from primary location.  Attempting with failover location.")
                    failoverlocation=p.getAttribute("failoverlocation")
                    self.Util.Endpoint=failoverlocation.split('/')[2]
                    Log("Plugin failover server is: " +  self.Util.Endpoint)
                    SimpleLog(p.plugin_log,"Plugin failover server is: " +  self.Util.Endpoint)

manifest=self.Util.HttpGetWithoutHeaders(failoverlocation, chkProxy=True)
                #if failoverlocation also fail what to do then?
                if manifest == None:
                    AddExtensionEvent(name,WALAEventOperation.Download,False,0,version,"Download mainfest fail "+failoverlocation)
                    Log("Plugin manifest " + name + " downloading failed from failover location.")
                    SimpleLog(p.plugin_log,"Plugin manifest " + name + " downloading failed from failover location.")

filepath=LibDir+"/" + name + '.' + incarnation + '.manifest'
                if os.path.splitext(location)[-1] == '.xml' : #if this is an xml file we may have a BOM
                    if ord(manifest[0]) > 128 and ord(manifest[1]) > 128 and ord(manifest[2]) > 128:
                        manifest=manifest[3:]
                SetFileContents(filepath,manifest)
                #Get the bundle url from the manifest
                p.setAttribute('manifestdata',manifest)
                man_dom = xml.dom.minidom.parseString(manifest)
                bundle_uri = ""
                for mp in man_dom.getElementsByTagName("Plugin"):
                    if GetNodeTextData(mp.getElementsByTagName("Version")[0]) == version:
                        bundle_uri = GetNodeTextData(mp.getElementsByTagName("Uri")[0])
                        break
                if len(mp.getElementsByTagName("DisallowMajorVersionUpgrade")):
                    if GetNodeTextData(mp.getElementsByTagName("DisallowMajorVersionUpgrade")[0]) == 'true' and previous_version !=None and previous_version.split('.')[0] != version.split('.')[0] :
                        Log('DisallowMajorVersionUpgrade is true, this major version is restricted from upgrade.')
                        SimpleLog(p.plugin_log,'DisallowMajorVersionUpgrade is true, this major version is restricted from upgrade.')
                        p.setAttribute('restricted','true')
                        continue
                if len(bundle_uri) < 1 :
                    Error("Unable to fetch Bundle URI from manifest for " + name + " v " + version)
                    SimpleLog(p.plugin_log,"Unable to fetch Bundle URI from manifest for " + name + " v " + version)
                    continue
                Log("Bundle URI = " + bundle_uri)
                SimpleLog(p.plugin_log,"Bundle URI = " + bundle_uri)

# Download the zipfile archive and save as '.zip'
                bundle=self.Util.HttpGetWithoutHeaders(bundle_uri, chkProxy=True)
                if bundle == None:
                    AddExtensionEvent(name,WALAEventOperation.Download,True,0,version,"Download zip fail "+bundle_uri)
                    Error("Unable to download plugin bundle" + bundle_uri )
                    SimpleLog(p.plugin_log,"Unable to download plugin bundle" + bundle_uri )
                    continue
                AddExtensionEvent(name,WALAEventOperation.Download,True,0,version,"Download Success")
                b=bytearray(bundle)
                filepath=LibDir+"/" + os.path.basename(bundle_uri) + '.zip'
                SetFileContents(filepath,b)
                Log("Plugin bundle" + bundle_uri + "downloaded successfully length = " + str(len(bundle)))
                SimpleLog(p.plugin_log,"Plugin bundle" + bundle_uri + "downloaded successfully length = " + str(len(bundle)))

# unpack the archive
                z=zipfile.ZipFile(filepath)
                zip_dir=LibDir+"/" + name + '-' + version
                z.extractall(zip_dir)
                Log('Extracted ' + bundle_uri + ' to ' + zip_dir) 
                SimpleLog(p.plugin_log,'Extracted ' + bundle_uri + ' to ' + zip_dir)

# zip no file perms in .zip so set all the scripts to +x
                Run( "find " + zip_dir +" -type f | xargs chmod  u+x ")
                #write out the base64 config data so the plugin can process it.
                mfile=None
                for root, dirs, files in os.walk(zip_dir):
                    for f in files:
                        if f in ('HandlerManifest.json'):
                            mfile=os.path.join(root,f)
                    if mfile != None:
                        break
                if mfile == None :
                    Error('HandlerManifest.json not found.')
                    SimpleLog(p.plugin_log,'HandlerManifest.json not found.')
                    continue
                manifest = GetFileContents(mfile)
                p.setAttribute('manifestdata',manifest)
                # create the status and config dirs
                Run('mkdir -p ' + root + '/status')
                Run('mkdir -p ' + root + '/config')
                # write out the configuration data to goalStateIncarnation.settings file in the config path.
                config=''
                seqNo='0'
                if len(dom.getElementsByTagName("PluginSettings")) != 0 :
                    pslist=dom.getElementsByTagName("PluginSettings")[0].getElementsByTagName("Plugin")
                    for ps in pslist:
                        if name == ps.getAttribute("name") and version == ps.getAttribute("version"):
                            Log("Found RuntimeSettings for " + name + " V " + version)
                            SimpleLog(p.plugin_log,"Found RuntimeSettings for " + name + " V " + version)

config=GetNodeTextData(ps.getElementsByTagName("RuntimeSettings")[0])
                            seqNo=ps.getElementsByTagName("RuntimeSettings")[0].getAttribute("seqNo") 
                            break
                if config == '':
                    Log("No RuntimeSettings for " + name + " V " + version)
                    SimpleLog(p.plugin_log,"No RuntimeSettings for " + name + " V " + version)

SetFileContents(root +"/config/" + seqNo +".settings",  config )
                #create HandlerEnvironment.json
                handler_env='[{  "name": "'+name+'", "seqNo": "'+seqNo+'", "version": 1.0,  "handlerEnvironment": {    "logFolder": "'+os.path.dirname(p.plugin_log)+'",    "configFolder": "' + root + '/config",    "statusFolder": "' + root + '/status",    "heartbeatFile": "'+ root + '/heartbeat.log"}}]'
                SetFileContents(root+'/HandlerEnvironment.json',handler_env)
                self.SetHandlerState(handler, 'NotInstalled')

cmd = ''
                getcmd='installCommand'
                if plg_dir != None and previous_version != None and LooseVersion(version) > LooseVersion(previous_version):
                    previous_handler=name+'-'+previous_version
                    if self.GetHandlerState(previous_handler) != 'NotInstalled':
                        getcmd='updateCommand'
                        # disable the old plugin if it exists
                        if self.launchCommand(p.plugin_log,name,previous_version,'disableCommand') == None :
                            self.SetHandlerState(previous_handler, 'Enabled')
                            Error('Unable to disable old plugin '+name+' version ' + previous_version)
                            SimpleLog(p.plugin_log,'Unable to disable old plugin '+name+' version ' + previous_version)
                        else :
                            self.SetHandlerState(previous_handler, 'Disabled')
                            Log(name+' version ' + previous_version + ' is disabled')
                            SimpleLog(p.plugin_log,name+' version ' + previous_version + ' is disabled')
                    
                        try:
                            Log("Copy status file from old plugin dir to new")
                            old_plg_dir = plg_dir 
                            new_plg_dir = os.path.join(LibDir, "{0}-{1}".format(name, version))
                            old_ext_status_dir = os.path.join(old_plg_dir, "status")
                            new_ext_status_dir = os.path.join(new_plg_dir, "status")
                            if os.path.isdir(old_ext_status_dir):
                                for status_file in os.listdir(old_ext_status_dir):
                                    status_file_path = os.path.join(old_ext_status_dir, status_file)
                                    if os.path.isfile(status_file_path):
                                        shutil.copy2(status_file_path, new_ext_status_dir)
                            mrseq_file = os.path.join(old_plg_dir, "mrseq")
                            if os.path.isfile(mrseq_file):
                                shutil.copy(mrseq_file, new_plg_dir)
                        except Exception as e:
                            Error("Failed to copy status file.")

isupgradeSuccess = True
                if getcmd=='updateCommand':
                    if self.launchCommand(p.plugin_log,name,version,getcmd,previous_version) == None :
                        Error('Update failed for '+name+'-'+version)
                        SimpleLog(p.plugin_log,'Update failed for '+name+'-'+version)
                        isupgradeSuccess=False
                    else :
                        Log('Update complete'+name+'-'+version)
                        SimpleLog(p.plugin_log,'Update complete'+name+'-'+version)

# if we updated - call unistall for the old plugin
                    if self.launchCommand(p.plugin_log,name,previous_version,'uninstallCommand') == None :
                        self.SetHandlerState(previous_handler, 'Installed')
                        Error('Uninstall failed for '+name+'-'+previous_version)
                        SimpleLog(p.plugin_log,'Uninstall failed for '+name+'-'+previous_version)
                        isupgradeSuccess=False
                    else :
                        self.SetHandlerState(previous_handler, 'NotInstalled')
                        Log('Uninstall complete'+ previous_handler )
                        SimpleLog(p.plugin_log,'Uninstall complete'+ name +'-' + previous_version)
                    
                    try:
                        #rm old plugin dir
                        if os.path.isdir(plg_dir):
                            shutil.rmtree(plg_dir)
                            Log(name +'-'+ previous_version + ' extension files deleted.')
                            SimpleLog(p.plugin_log,name +'-'+ previous_version + ' extension files deleted.')
                    except Exception as e:
                        Error("Failed to remove old plugin directory")

AddExtensionEvent(name,WALAEventOperation.Upgrade,isupgradeSuccess,0,previous_version)
                else :  # run install
                    if self.launchCommand(p.plugin_log,name,version,getcmd) == None :
                        self.SetHandlerState(handler, 'NotInstalled')
                        Error('Installation failed for '+name+'-'+version)
                        SimpleLog(p.plugin_log,'Installation failed for '+name+'-'+version)
                    else :
                        self.SetHandlerState(handler, 'Installed')
                        Log('Installation completed for '+name+'-'+version)
                        SimpleLog(p.plugin_log,'Installation completed for '+name+'-'+version)

#end if plg_dir == none or version > = prev
            # change incarnation of settings file so it knows how to name status...
            zip_dir=LibDir+"/" + name + '-' + version
            mfile=None
            for root, dirs, files in os.walk(zip_dir):
                for f in files:
                    if f in ('HandlerManifest.json'):
                        mfile=os.path.join(root,f)
                if mfile != None:
                    break
            if mfile == None :
                Error('HandlerManifest.json not found.')
                SimpleLog(p.plugin_log,'HandlerManifest.json not found.')

continue
            manifest = GetFileContents(mfile)
            p.setAttribute('manifestdata',manifest)
            config=''
            seqNo='0'
            if len(dom.getElementsByTagName("PluginSettings")) != 0 :
                try:
                    pslist=dom.getElementsByTagName("PluginSettings")[0].getElementsByTagName("Plugin")
                except:
                    Error('Error parsing ExtensionsConfig.')
                    SimpleLog(p.plugin_log,'Error parsing ExtensionsConfig.')

continue
                for ps in pslist:
                    if name == ps.getAttribute("name") and version == ps.getAttribute("version"):
                        Log("Found RuntimeSettings for " + name + " V " + version)
                        SimpleLog(p.plugin_log,"Found RuntimeSettings for " + name + " V " + version)

config=GetNodeTextData(ps.getElementsByTagName("RuntimeSettings")[0])
                        seqNo=ps.getElementsByTagName("RuntimeSettings")[0].getAttribute("seqNo") 
                        break
            if config == '':
                Error("No RuntimeSettings for " + name + " V " + version)
                SimpleLog(p.plugin_log,"No RuntimeSettings for " + name + " V " + version)

SetFileContents(root +"/config/" + seqNo +".settings",  config )

# state is still enable
            if (self.GetHandlerState(handler) == 'NotInstalled'):  # run install first if true
                if self.launchCommand(p.plugin_log,name,version,'installCommand') == None :
                    self.SetHandlerState(handler, 'NotInstalled')
                    Error('Installation failed for '+name+'-'+version)
                    SimpleLog(p.plugin_log,'Installation failed for '+name+'-'+version)

else :
                    self.SetHandlerState(handler, 'Installed')
                    Log('Installation completed for '+name+'-'+version)
                    SimpleLog(p.plugin_log,'Installation completed for '+name+'-'+version)

if (self.GetHandlerState(handler) != 'NotInstalled'):
                if self.launchCommand(p.plugin_log,name,version,'enableCommand') == None :
                    self.SetHandlerState(handler, 'Installed')
                    Error('Enable failed for '+name+'-'+version)
                    SimpleLog(p.plugin_log,'Enable failed for '+name+'-'+version)

else :
                    self.SetHandlerState(handler, 'Enabled')
                    Log('Enable completed for '+name+'-'+version)
                    SimpleLog(p.plugin_log,'Enable completed for '+name+'-'+version)

# this plugin processing is complete
            Log('Processing completed for '+name+'-'+version)
            SimpleLog(p.plugin_log,'Processing completed for '+name+'-'+version)

#end plugin processing loop
        Log('Finished processing ExtensionsConfig.xml')
        try:
            SimpleLog(p.plugin_log,'Finished processing ExtensionsConfig.xml')
        except:
            pass
        
        return self
    def launchCommand(self,plugin_log,name,version,command,prev_version=None):
        commandToEventOperation={
        "installCommand":WALAEventOperation.Install,
        "uninstallCommand":WALAEventOperation.UnIsntall,
        "updateCommand": WALAEventOperation.Upgrade,
        "enableCommand": WALAEventOperation.Enable,
        "disableCommand": WALAEventOperation.Disable,
        }
        isSuccess=True
        start = datetime.datetime.now()
        r=self.__launchCommandWithoutEventLog(plugin_log,name,version,command,prev_version)
        if r==None:
            isSuccess=False
        Duration = int((datetime.datetime.now() - start).seconds)
        if commandToEventOperation.get(command):
            AddExtensionEvent(name,commandToEventOperation[command],isSuccess,Duration,version)
        return r

def __launchCommandWithoutEventLog(self,plugin_log,name,version,command,prev_version=None):
        # get the manifest and read the command
        mfile=None
        zip_dir=LibDir+"/" + name + '-' + version
        for root, dirs, files in os.walk(zip_dir):
            for f in files:
                if f in ('HandlerManifest.json'):
                    mfile=os.path.join(root,f)
            if mfile != None:
                break
        if mfile == None :
            Error('HandlerManifest.json not found.')
            SimpleLog(plugin_log,'HandlerManifest.json not found.')
            
            return None
        manifest = GetFileContents(mfile)
        try:
            jsn = json.loads(manifest)
        except:
            Error('Error parsing HandlerManifest.json.')
            SimpleLog(plugin_log,'Error parsing HandlerManifest.json.')

return None
        if type(jsn)==list:
            jsn=jsn[0]
        if jsn.has_key('handlerManifest') :
            cmd = jsn['handlerManifest'][command]
        else :
            Error('Key handlerManifest not found.  Handler cannot be installed.')
            SimpleLog(plugin_log,'Key handlerManifest not found.  Handler cannot be installed.')

if len(cmd) == 0 :
            Error('Unable to read ' + command )
            SimpleLog(plugin_log,'Unable to read ' + command )

return None

# for update we send the path of the old installation
        arg=''
        if prev_version != None :
            arg=' ' + LibDir+'/' + name + '-' + prev_version
        dirpath=os.path.dirname(mfile)
        LogIfVerbose('Command is '+ dirpath+'/'+ cmd)
        # launch
        pid=None
        try:
            child = subprocess.Popen(dirpath+'/'+cmd+arg,shell=True,cwd=dirpath,stdout=subprocess.PIPE)
        except Exception as e:
            Error('Exception launching ' + cmd + str(e))
            SimpleLog(plugin_log,'Exception launching ' + cmd + str(e))

pid = child.pid
        if pid == None or pid < 1 :
            ExtensionChildren.append((-1,root))
            Error('Error launching ' + cmd + '.')
            SimpleLog(plugin_log,'Error launching ' + cmd + '.')

else :
            ExtensionChildren.append((pid,root))
            Log("Spawned "+ cmd + " PID " + str(pid))
            SimpleLog(plugin_log,"Spawned "+ cmd + " PID " + str(pid))

# wait until install/upgrade is finished
        timeout = 300 # 5 minutes
        retry = timeout/5
        while retry > 0 and child.poll() == None:
            LogIfVerbose(cmd + ' still running with PID ' + str(pid))
            time.sleep(5)
            retry-=1
        if retry==0:
            Error('Process exceeded timeout of ' + str(timeout) + ' seconds. Terminating process ' + str(pid))
            SimpleLog(plugin_log,'Process exceeded timeout of ' + str(timeout) + ' seconds. Terminating process ' + str(pid))

os.kill(pid,9)
            return None
        code = child.wait()
        if code == None or code != 0:
            Error('Process ' + str(pid) + ' returned non-zero exit code (' + str(code) + ')')
            SimpleLog(plugin_log,'Process ' + str(pid) + ' returned non-zero exit code (' + str(code) + ')')

return None
        Log(command + ' completed.')
        SimpleLog(plugin_log,command + ' completed.')

return 0

def ReportHandlerStatus(self):
        """
        Collect all status reports.
        """
        # { "version": "1.0", "timestampUTC": "2014-03-31T21:28:58Z", 
        # "aggregateStatus": { 
        # "guestAgentStatus": { "version": "2.0.4PRE", "status": "Ready", "formattedMessage": { "lang": "en-US", "message": "GuestAgent is running and accepting new configurations." } }, 
        # "handlerAggregateStatus": [{ 
        # "handlerName": "ExampleHandlerLinux", "handlerVersion": "1.0", "status": "Ready", "runtimeSettingsStatus": { 
        # "sequenceNumber": "2", "settingsStatus": { "timestampUTC": "2014-03-31T23:46:00Z", "status": { "name": "ExampleHandlerLinux", "operation": "Command Execution Finished", "configurationAppliedTime": "2014-03-31T23:46:00Z", "status": "success", "formattedMessage": { "lang": "en-US", "message": "Finished executing command" }, 
        # "substatus": [
        # { "name": "StdOut", "status": "success", "formattedMessage": { "lang": "en-US", "message": "Goodbye world!" }  }, 
        # { "name": "StdErr", "status": "success", "formattedMessage": { "lang": "en-US", "message": "" } }
        # ] 
        # } } } }
        # ]
        #  }}

try:
            incarnation=self.Extensions[0].getAttribute("goalStateIncarnation")
        except:
            Error('Error parsing attribute "goalStateIncarnation".  Unable to send status reports')
            return -1
        status=''
        statuses=''
        for p in self.Plugins:
            if p.getAttribute("state") == 'uninstall' or p.getAttribute("restricted") == 'true' :
                continue
            version=p.getAttribute("version")
            name=p.getAttribute("name")
            if p.getAttribute("isJson") != 'true':
                LogIfVerbose("Plugin " + name+" version: " +version+" is not a JSON Extension.  Skipping.")
                continue
            reportHeartbeat = False
            if len(p.getAttribute("manifestdata"))<1:
                Error("Failed to get manifestdata.")
            else:
                reportHeartbeat = json.loads(p.getAttribute("manifestdata"))[0]['handlerManifest']['reportHeartbeat']
            if len(statuses)>0:
                statuses+=','
            statuses+=self.GenerateAggStatus(name, version, reportHeartbeat)
        tstamp=time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
        #header
        #agent state
        if provisioned == False:
            if provisionError == None :
                agent_state='Provisioning'
                agent_msg='Guest Agent is starting.'
            else:
                agent_state='Provisioning Error.'
                agent_msg=provisionError
        else:
            agent_state='Ready'
            agent_msg='GuestAgent is running and accepting new configurations.'
            
        status='{"version":"1.0","timestampUTC":"'+tstamp+'","aggregateStatus":{"guestAgentStatus":{"version":"'+GuestAgentVersion+'","status":"'+agent_state+'","formattedMessage":{"lang":"en-US","message":"'+agent_msg+'"}},"handlerAggregateStatus":['+statuses+']}}'
        try:
            uri=GetNodeTextData(self.Extensions[0].getElementsByTagName("StatusUploadBlob")[0]).replace('&amp;','&')
        except:
            Error('Error parsing element "StatusUploadBlob".  Unable to send status reports')
            return -1

LogIfVerbose('Status report '+status+' sent to ' + uri)
        return UploadStatusBlob(uri, status.encode("utf-8"))

def GetCurrentSequenceNumber(self, plugin_base_dir):
        """
        Get the settings file with biggest file number in config folder
        """
        config_dir = os.path.join(plugin_base_dir, 'config')
        seq_no = 0
        for subdir, dirs, files in os.walk(config_dir):
            for file in files:
                try:
                    cur_seq_no = int(os.path.basename(file).split('.')[0])
                    if cur_seq_no > seq_no:
                        seq_no = cur_seq_no
                except ValueError:
                    continue
        return str(seq_no)

def GenerateAggStatus(self, name, version, reportHeartbeat = False):
        """
        Generate the status which Azure can understand by the status and heartbeat reported by extension
        """
        plugin_base_dir = LibDir+'/'+name+'-'+version+'/'
        current_seq_no = self.GetCurrentSequenceNumber(plugin_base_dir)
        status_file=os.path.join(plugin_base_dir, 'status/', current_seq_no +'.status')
        heartbeat_file = os.path.join(plugin_base_dir, 'heartbeat.log')

handler_state_file = os.path.join(plugin_base_dir,  'config', 'HandlerState')
        agg_state = 'NotReady'
        handler_state = None
        status_obj = None
        status_code = None
        formatted_message = None
        localized_message = None

if os.path.exists(handler_state_file):
            handler_state = GetFileContents(handler_state_file).lower()
        if HandlerStatusToAggStatus.has_key(handler_state):
            agg_state = HandlerStatusToAggStatus[handler_state]
        if reportHeartbeat:
            if os.path.exists(heartbeat_file):
                d=int(time.time()-os.stat(heartbeat_file).st_mtime)
                if d > 600 :    # not updated for more than 10 min
                    agg_state = 'Unresponsive'
                else:
                    try:
                        heartbeat = json.loads(GetFileContents(heartbeat_file))[0]["heartbeat"]
                        agg_state = heartbeat.get("status")
                        status_code = heartbeat.get("code")
                        formatted_message = heartbeat.get("formattedMessage")
                        localized_message = heartbeat.get("message")
                    except:
                        Error("Incorrect heartbeat file. Ignore it. ")
            else:
                agg_state = 'Unresponsive'
        #get status file reported by extension
        if os.path.exists(status_file):
            # raw status generated by extension is an array, get the first item and remove the unnecessary element
            try:
                status_obj = json.loads(GetFileContents(status_file))[0]
                del status_obj["version"]
            except:
                Error("Incorrect status file. Will NOT settingsStatus in settings. ")
        agg_status_obj = {"handlerName": name, "handlerVersion": version, "status": agg_state, "runtimeSettingsStatus" :
                {"sequenceNumber": current_seq_no}}
        if status_obj:
            agg_status_obj["runtimeSettingsStatus"]["settingsStatus"] = status_obj
        if status_code != None:
            agg_status_obj["code"] = status_code
        if formatted_message:
            agg_status_obj["formattedMessage"] = formatted_message
        if localized_message:
            agg_status_obj["message"] = localized_message
        agg_status_string = json.dumps(agg_status_obj)
        LogIfVerbose("Handler Aggregated Status:" + agg_status_string)
        return agg_status_string

def SetHandlerState(self, handler, state=''):
        zip_dir=LibDir+"/" + handler
        mfile=None
        for root, dirs, files in os.walk(zip_dir):
            for f in files:
                if f in ('HandlerManifest.json'):
                    mfile=os.path.join(root,f)
            if mfile != None:
                break
        if mfile == None :
            Error('SetHandlerState(): HandlerManifest.json not found, cannot set HandlerState.')
            return None
        Log("SetHandlerState: "+handler+", "+state)
        return SetFileContents(os.path.dirname(mfile)+'/config/HandlerState', state)

def GetHandlerState(self, handler):
        handlerState = GetFileContents(handler+'/config/HandlerState')
        if (handlerState):
            return handlerState.rstrip('\r\n')
        else:
            return 'NotInstalled'

class HostingEnvironmentConfig(object):
    """
    Parse Hosting enviromnet config and store in
    HostingEnvironmentConfig.xml
    """
    #
    # <HostingEnvironmentConfig version="1.0.0.0" goalStateIncarnation="1">
    #   <StoredCertificates>
    #     <StoredCertificate name="Stored0Microsoft.WindowsAzure.Plugins.RemoteAccess.PasswordEncryption" certificateId="sha1:C093FA5CD3AAE057CB7C4E04532B2E16E07C26CA" storeName="My" configurationLevel="System" />
    #   </StoredCertificates>
    #   <Deployment name="db00a7755a5e4e8a8fe4b19bc3b330c3" guid="{ce5a036f-5c93-40e7-8adf-2613631008ab}" incarnation="2">
    #     <Service name="MyVMRoleService" guid="{00000000-0000-0000-0000-000000000000}" />
    #     <ServiceInstance name="db00a7755a5e4e8a8fe4b19bc3b330c3.1" guid="{d113f4d7-9ead-4e73-b715-b724b5b7842c}" />
    #   </Deployment>
    #   <Incarnation number="1" instance="MachineRole_IN_0" guid="{a0faca35-52e5-4ec7-8fd1-63d2bc107d9b}" />
    #   <Role guid="{73d95f1c-6472-e58e-7a1a-523554e11d46}" name="MachineRole" hostingEnvironmentVersion="1" software="" softwareType="ApplicationPackage" entryPoint="" parameters="" settleTimeSeconds="10" />
    #   <HostingEnvironmentSettings name="full" Runtime="rd_fabric_stable.110217-1402.RuntimePackage_1.0.0.8.zip">
    #     <CAS mode="full" />
    #     <PrivilegeLevel mode="max" />
    #     <AdditionalProperties><CgiHandlers></CgiHandlers></AdditionalProperties>
    #   </HostingEnvironmentSettings>
    #   <ApplicationSettings>
    #     <Setting name="__ModelData" value="&lt;m role=&quot;MachineRole&quot; xmlns=&quot;urn:azure:m:v1&quot;>&lt;r name=&quot;MachineRole&quot;>&lt;e name=&quot;a&quot; />&lt;e name=&quot;b&quot; />&lt;e name=&quot;Microsoft.WindowsAzure.Plugins.RemoteAccess.Rdp&quot; />&lt;e name=&quot;Microsoft.WindowsAzure.Plugins.RemoteForwarder.RdpInput&quot; />&lt;/r>&lt;/m>" />
    #     <Setting name="Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString" value="DefaultEndpointsProtocol=http;AccountName=osimages;AccountKey=DNZQ..." />
    #     <Setting name="Microsoft.WindowsAzure.Plugins.RemoteForwarder.Enabled" value="true" />
    #   </ApplicationSettings>
    #   <ResourceReferences>
    #     <Resource name="DiagnosticStore" type="directory" request="Microsoft.Cis.Fabric.Controller.Descriptions.ServiceDescription.Data.Policy" sticky="true" size="1" path="db00a7755a5e4e8a8fe4b19bc3b330c3.MachineRole.DiagnosticStore\" disableQuota="false" />
    #   </ResourceReferences>
    # </HostingEnvironmentConfig>
    #
    def __init__(self):
        self.reinitialize()

def reinitialize(self):
        """
        Reset Members.
        """
        self.StoredCertificates = None
        self.Deployment = None
        self.Incarnation = None
        self.Role = None
        self.HostingEnvironmentSettings = None
        self.ApplicationSettings = None
        self.Certificates = None
        self.ResourceReferences = None

def Parse(self, xmlText):
        """
        Parse and create HostingEnvironmentConfig.xml.
        """
        self.reinitialize()
        SetFileContents("HostingEnvironmentConfig.xml", xmlText)
        dom = xml.dom.minidom.parseString(xmlText)
        for a in [ "HostingEnvironmentConfig", "Deployment", "Service",
                   "ServiceInstance", "Incarnation", "Role", ]:
            if not dom.getElementsByTagName(a):
                Error("HostingEnvironmentConfig.Parse: Missing " + a)
                return None
        node = dom.childNodes[0]
        if node.localName != "HostingEnvironmentConfig":
            Error("HostingEnvironmentConfig.Parse: root not HostingEnvironmentConfig")
            return None
        self.ApplicationSettings = dom.getElementsByTagName("Setting")
        self.Certificates = dom.getElementsByTagName("StoredCertificate")
        return self

def DecryptPassword(self, e):
        """
        Return decrypted password.
        """
        SetFileContents("password.p7m",
            "MIME-Version: 1.0\n"
            + "Content-Disposition: attachment; filename=\"password.p7m\"\n"
            + "Content-Type: application/x-pkcs7-mime; name=\"password.p7m\"\n"
            + "Content-Transfer-Encoding: base64\n\n"
            + textwrap.fill(e, 64))
        return RunGetOutput(Openssl + " cms -decrypt -in password.p7m -inkey Certificates.pem -recip Certificates.pem")[1]

def ActivateResourceDisk(self):
        return MyDistro.ActivateResourceDisk()

def Process(self):
        """
        Execute ActivateResourceDisk in separate thread.
        Create the user account.
        Launch ConfigurationConsumer if specified in the config.
        """
        no_thread = False
        if DiskActivated == False:
            for m in inspect.getmembers(MyDistro):
                if 'ActivateResourceDiskNoThread' in m:
                    no_thread = True
                    break
            if no_thread == True :   
                MyDistro.ActivateResourceDiskNoThread()
            else :
                diskThread = threading.Thread(target = self.ActivateResourceDisk)
                diskThread.start()
        User = None
        Pass = None
        Expiration = None
        Thumbprint = None
        for b in self.ApplicationSettings:
            sname = b.getAttribute("name")
            svalue = b.getAttribute("value")
        if User != None and Pass != None:
            if User != "root" and User != "" and Pass != "":
                CreateAccount(User, Pass, Expiration, Thumbprint)
            else:
                Error("Not creating user account: " + User)
        for c in self.Certificates:
            csha1 = c.getAttribute("certificateId").split(':')[1].upper()
            if os.path.isfile(csha1 + ".prv"):
                Log("Private key with thumbprint: " + csha1 + " was retrieved.")
            if os.path.isfile(csha1 + ".crt"):
                Log("Public cert with thumbprint: " + csha1 + " was retrieved.")
        program = Config.get("Role.ConfigurationConsumer")
        if program != None:
            try:
                Children.append(subprocess.Popen([program, LibDir + "/HostingEnvironmentConfig.xml"]))
            except OSError, e :
                ErrorWithPrefix('HostingEnvironmentConfig.Process','Exception: '+ str(e) +' occured launching ' + program )

class GoalState(Util):
    """
    Primary container for all configuration except OvfXml.
    Encapsulates http communication with endpoint server.
    Initializes and populates:
    self.HostingEnvironmentConfig
    self.SharedConfig
    self.ExtensionsConfig
    self.Certificates
    """
    #
    # <GoalState xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="goalstate10.xsd">
    #   <Version>2010-12-15</Version>
    #   <Incarnation>1</Incarnation>
    #   <Machine>
    #     <ExpectedState>Started</ExpectedState>
    #     <LBProbePorts>
    #       <Port>16001</Port>
    #     </LBProbePorts>
    #   </Machine>
    #   <Container>
    #     <ContainerId>c6d5526c-5ac2-4200-b6e2-56f2b70c5ab2</ContainerId>
    #     <RoleInstanceList>
    #       <RoleInstance>
    #         <InstanceId>MachineRole_IN_0</InstanceId>
    #         <State>Started</State>
    #         <Configuration>
    #           <HostingEnvironmentConfig>http://10.115.153.40:80/machine/c6d5526c-5ac2-4200-b6e2-56f2b70c5ab2/MachineRole%5FIN%5F0?comp=config&amp;type=hostingEnvironmentConfig&amp;incarnation=1</HostingEnvironmentConfig>
    #           <SharedConfig>http://10.115.153.40:80/machine/c6d5526c-5ac2-4200-b6e2-56f2b70c5ab2/MachineRole%5FIN%5F0?comp=config&amp;type=sharedConfig&amp;incarnation=1</SharedConfig>
    #           <Certificates>http://10.115.153.40:80/machine/c6d5526c-5ac2-4200-b6e2-56f2b70c5ab2/MachineRole%5FIN%5F0?comp=certificates&amp;incarnation=1</Certificates>
    #          <ExtensionsConfig>http://100.67.238.230:80/machine/9c87aa94-3bda-45e3-b2b7-0eb0fca7baff/1552dd64dc254e6884f8d5b8b68aa18f.eg%2Dplug%2Dvm?comp=config&amp;type=extensionsConfig&amp;incarnation=2</ExtensionsConfig>
    #         <FullConfig>http://100.67.238.230:80/machine/9c87aa94-3bda-45e3-b2b7-0eb0fca7baff/1552dd64dc254e6884f8d5b8b68aa18f.eg%2Dplug%2Dvm?comp=config&amp;type=fullConfig&amp;incarnation=2</FullConfig>

#         </Configuration>
    #       </RoleInstance>
    #     </RoleInstanceList>
    #   </Container>
    # </GoalState>
    #
    # There is only one Role for VM images.
    #
    # Of primary interest is:
    #  LBProbePorts -- an http server needs to run here
    #  We also note Container/ContainerID and RoleInstance/InstanceId to form the health report.
    #  And of course, Incarnation
    #
    def __init__(self, Agent):
        self.Agent = Agent
        self.Endpoint = Agent.Endpoint
        self.TransportCert = Agent.TransportCert
        self.reinitialize()

def reinitialize(self):
        self.Incarnation = None # integer
        self.ExpectedState = None # "Started"
        self.HostingEnvironmentConfigUrl = None
        self.HostingEnvironmentConfigXml = None
        self.HostingEnvironmentConfig = None
        self.SharedConfigUrl = None
        self.SharedConfigXml = None
        self.SharedConfig = None
        self.CertificatesUrl = None
        self.CertificatesXml = None
        self.Certificates = None
        self.ExtensionsConfigUrl = None
        self.ExtensionsConfigXml = None
        self.ExtensionsConfig = None
        self.RoleInstanceId = None
        self.ContainerId = None
        self.LoadBalancerProbePort = None # integer, ?list of integers

def Parse(self, xmlText):
        """
        Request configuration data from endpoint server.
        Parse and populate contained configuration objects.
        Calls Certificates().Parse()
        Calls SharedConfig().Parse
        Calls ExtensionsConfig().Parse
        Calls HostingEnvironmentConfig().Parse
        """
        self.reinitialize()
        LogIfVerbose(xmlText)
        node = xml.dom.minidom.parseString(xmlText).childNodes[0]
        if node.localName != "GoalState":
            Error("GoalState.Parse: root not GoalState")
            return None
        for a in node.childNodes:
            if a.nodeType == node.ELEMENT_NODE:
                if a.localName == "Incarnation":
                    self.Incarnation = GetNodeTextData(a)
                elif a.localName == "Machine":
                    for b in a.childNodes:
                        if b.nodeType == node.ELEMENT_NODE:
                            if b.localName == "ExpectedState":
                                self.ExpectedState = GetNodeTextData(b)
                                Log("ExpectedState: " + self.ExpectedState)
                            elif b.localName == "LBProbePorts":
                                for c in b.childNodes:
                                    if c.nodeType == node.ELEMENT_NODE and c.localName == "Port":
                                        self.LoadBalancerProbePort = int(GetNodeTextData(c))
                elif a.localName == "Container":
                    for b in a.childNodes:
                        if b.nodeType == node.ELEMENT_NODE:
                            if b.localName == "ContainerId":
                                self.ContainerId = GetNodeTextData(b)
                                Log("ContainerId: " + self.ContainerId)
                            elif b.localName == "RoleInstanceList":
                                for c in b.childNodes:
                                    if c.localName == "RoleInstance":
                                        for d in c.childNodes:
                                            if d.nodeType == node.ELEMENT_NODE:
                                                if d.localName == "InstanceId":
                                                    self.RoleInstanceId = GetNodeTextData(d)
                                                    Log("RoleInstanceId: " + self.RoleInstanceId)
                                                elif d.localName == "State":
                                                    pass
                                                elif d.localName == "Configuration":
                                                    for e in d.childNodes:
                                                        if e.nodeType == node.ELEMENT_NODE:
                                                            LogIfVerbose(e.localName)
                                                            if e.localName == "HostingEnvironmentConfig":
                                                                self.HostingEnvironmentConfigUrl = GetNodeTextData(e)
                                                                LogIfVerbose("HostingEnvironmentConfigUrl:" + self.HostingEnvironmentConfigUrl)
                                                                self.HostingEnvironmentConfigXml = self.HttpGetWithHeaders(self.HostingEnvironmentConfigUrl)
                                                                self.HostingEnvironmentConfig = HostingEnvironmentConfig().Parse(self.HostingEnvironmentConfigXml)
                                                            elif e.localName == "SharedConfig":
                                                                self.SharedConfigUrl = GetNodeTextData(e)
                                                                LogIfVerbose("SharedConfigUrl:" + self.SharedConfigUrl)
                                                                self.SharedConfigXml = self.HttpGetWithHeaders(self.SharedConfigUrl)
                                                                self.SharedConfig = SharedConfig().Parse(self.SharedConfigXml)
                                                                self.SharedConfig.Save()
                                                            elif e.localName == "ExtensionsConfig":
                                                                self.ExtensionsConfigUrl = GetNodeTextData(e)
                                                                LogIfVerbose("ExtensionsConfigUrl:" + self.ExtensionsConfigUrl)
                                                                self.ExtensionsConfigXml = self.HttpGetWithHeaders(self.ExtensionsConfigUrl)
                                                            elif e.localName == "Certificates":
                                                                self.CertificatesUrl = GetNodeTextData(e)
                                                                LogIfVerbose("CertificatesUrl:" + self.CertificatesUrl)
                                                                self.CertificatesXml = self.HttpSecureGetWithHeaders(self.CertificatesUrl, self.TransportCert)
                                                                self.Certificates = Certificates().Parse(self.CertificatesXml)
        if self.Incarnation == None:
            Error("GoalState.Parse: Incarnation missing")
            return None
        if self.ExpectedState == None:
            Error("GoalState.Parse: ExpectedState missing")
            return None
        if self.RoleInstanceId == None:
            Error("GoalState.Parse: RoleInstanceId missing")
            return None
        if self.ContainerId == None:
            Error("GoalState.Parse: ContainerId missing")
            return None
        SetFileContents("GoalState." + self.Incarnation + ".xml", xmlText)
        return self

def Process(self):
        """
        Calls HostingEnvironmentConfig.Process()
        """
        LogIfVerbose("Process goalstate")
        self.HostingEnvironmentConfig.Process()
        self.SharedConfig.Process()
        
class OvfEnv(object):
    """
    Read, and process provisioning info from provisioning file OvfEnv.xml
    """
    #
    # <?xml version="1.0" encoding="utf-8"?>
    # <Environment xmlns="http://schemas.dmtf.org/ovf/environment/1" xmlns:oe="http://schemas.dmtf.org/ovf/environment/1" xmlns:wa="http://schemas.microsoft.com/windowsazure" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    #    <wa:ProvisioningSection>
    #      <wa:Version>1.0</wa:Version>
    #      <LinuxProvisioningConfigurationSet xmlns="http://schemas.microsoft.com/windowsazure" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
    #        <ConfigurationSetType>LinuxProvisioningConfiguration</ConfigurationSetType>
    #        <HostName>HostName</HostName>
    #        <UserName>UserName</UserName>
    #        <UserPassword>UserPassword</UserPassword>
    #        <DisableSshPasswordAuthentication>false</DisableSshPasswordAuthentication>
    #        <SSH>
    #          <PublicKeys>
    #            <PublicKey>
    #              <Fingerprint>EB0C0AB4B2D5FC35F2F0658D19F44C8283E2DD62</Fingerprint>
    #              <Path>$HOME/UserName/.ssh/authorized_keys</Path>
    #            </PublicKey>
    #          </PublicKeys>
    #          <KeyPairs>
    #            <KeyPair>
    #              <Fingerprint>EB0C0AB4B2D5FC35F2F0658D19F44C8283E2DD62</Fingerprint>
    #              <Path>$HOME/UserName/.ssh/id_rsa</Path>
    #            </KeyPair>
    #          </KeyPairs>
    #        </SSH>
    #      </LinuxProvisioningConfigurationSet>
    #    </wa:ProvisioningSection>
    # </Environment>
    #
    def __init__(self):
        self.reinitialize()

def reinitialize(self):
        """
        Reset members.
        """
        self.WaNs = "http://schemas.microsoft.com/windowsazure"
        self.OvfNs = "http://schemas.dmtf.org/ovf/environment/1"
        self.MajorVersion = 1
        self.MinorVersion = 0
        self.ComputerName = None
        self.AdminPassword = None
        self.UserName = None
        self.UserPassword = None
        self.CustomData = None
        self.DisableSshPasswordAuthentication = True
        self.SshPublicKeys = []
        self.SshKeyPairs = []

def Parse(self, xmlText, isDeprovision = False):
        """
        Parse xml tree, retreiving user and ssh key information.
        Return self.
        """
        self.reinitialize()
        LogIfVerbose(re.sub("<UserPassword>.*?<", "<UserPassword>*<", xmlText))
        dom = xml.dom.minidom.parseString(xmlText)
        if len(dom.getElementsByTagNameNS(self.OvfNs, "Environment")) != 1:
            Error("Unable to parse OVF XML.")
        section = None
        newer = False
        for p in dom.getElementsByTagNameNS(self.WaNs, "ProvisioningSection"):
            for n in p.childNodes:
                if n.localName == "Version":
                    verparts = GetNodeTextData(n).split('.')
                    major = int(verparts[0])
                    minor = int(verparts[1])
                    if major > self.MajorVersion:
                        newer = True
                    if major != self.MajorVersion:
                        break
                    if minor > self.MinorVersion:
                        newer = True
                    section = p
        if newer == True:
            Warn("Newer provisioning configuration detected. Please consider updating waagent.")
        if section == None:
            Error("Could not find ProvisioningSection with major version=" + str(self.MajorVersion))
            return None
        self.ComputerName = GetNodeTextData(section.getElementsByTagNameNS(self.WaNs, "HostName")[0])
        self.UserName = GetNodeTextData(section.getElementsByTagNameNS(self.WaNs, "UserName")[0])
        if isDeprovision == True:
          return self
        try:
            self.UserPassword = GetNodeTextData(section.getElementsByTagNameNS(self.WaNs, "UserPassword")[0])
        except:
            pass
        CDSection=None
        try:
            CDSection=section.getElementsByTagNameNS(self.WaNs, "CustomData")
            if len(CDSection) > 0 :
                self.CustomData=GetNodeTextData(CDSection[0])
                if len(self.CustomData)>0:
                    SetFileContents(LibDir + '/CustomData', bytearray(MyDistro.translateCustomData(self.CustomData), 'utf-8'))
                    Log('Wrote ' + LibDir + '/CustomData')
                else :
                    Error('<CustomData> contains no data!')
        except Exception, e:
            Error( str(e)+' occured creating ' + LibDir + '/CustomData')
        disableSshPass = section.getElementsByTagNameNS(self.WaNs, "DisableSshPasswordAuthentication")
        if len(disableSshPass) != 0:
            self.DisableSshPasswordAuthentication = (GetNodeTextData(disableSshPass[0]).lower() == "true")
        for pkey in section.getElementsByTagNameNS(self.WaNs, "PublicKey"):
            LogIfVerbose(repr(pkey))
            fp = None
            path = None
            for c in pkey.childNodes:
                if c.localName == "Fingerprint":
                    fp = GetNodeTextData(c).upper()
                    LogIfVerbose(fp)
                if c.localName == "Path":
                    path = GetNodeTextData(c)
                    LogIfVerbose(path)
            self.SshPublicKeys += [[fp, path]]
        for keyp in section.getElementsByTagNameNS(self.WaNs, "KeyPair"):
            fp = None
            path = None
            LogIfVerbose(repr(keyp))
            for c in keyp.childNodes:
                if c.localName == "Fingerprint":
                    fp = GetNodeTextData(c).upper()
                    LogIfVerbose(fp)
                if c.localName == "Path":
                    path = GetNodeTextData(c)
                    LogIfVerbose(path)
            self.SshKeyPairs += [[fp, path]]
        return self

def PrepareDir(self, filepath):
        """
        Create home dir for self.UserName
        Change owner and return path.
        """
        home = MyDistro.GetHome()
        # Expand HOME variable if present in path
        path = os.path.normpath(filepath.replace("$HOME", home))
        if (path.startswith("/") == False) or (path.endswith("/") == True):
            return None
        dir = path.rsplit('/', 1)[0]
        if dir != "":
            CreateDir(dir, "root", 0700)
            if path.startswith(os.path.normpath(home + "/" + self.UserName + "/")):
                ChangeOwner(dir, self.UserName)
        return path

def NumberToBytes(self, i):
        """
        Pack number into bytes.  Retun as string.
        """
        result = []
        while i:
            result.append(chr(i & 0xFF))
            i >>= 8
        result.reverse()
        return ''.join(result)

def BitsToString(self, a):
        """
        Return string representation of bits in a.
        """
        index=7
        s = ""
        c = 0
        for bit in a:
            c = c | (bit << index)
            index = index - 1
            if index == -1:
                s = s + struct.pack('>B', c)
                c = 0
                index = 7
        return s

def OpensslToSsh(self, file):
        """
        Return base-64 encoded key appropriate for ssh.
        """
        from pyasn1.codec.der import decoder as der_decoder
        try:
            f = open(file).read().replace('\n','').split("KEY-----")[1].split('-')[0]
            k=der_decoder.decode(self.BitsToString(der_decoder.decode(base64.b64decode(f))[0][1]))[0]
            n=k[0]
            e=k[1]
            keydata=""
            keydata += struct.pack('>I',len("ssh-rsa"))
            keydata += "ssh-rsa"
            keydata += struct.pack('>I',len(self.NumberToBytes(e)))
            keydata += self.NumberToBytes(e)
            keydata += struct.pack('>I',len(self.NumberToBytes(n)) + 1)
            keydata += "\0"
            keydata += self.NumberToBytes(n)
        except Exception, e:
            print("OpensslToSsh: Exception " + str(e))
            return None
        return "ssh-rsa " + base64.b64encode(keydata) + "\n"

def Process(self):
        """
        Process all certificate and key info.
        DisableSshPasswordAuthentication if configured.
        CreateAccount(user)
        Wait for WaAgent.EnvMonitor.IsHostnamePublished().
        Restart ssh service.
        """
        error = None
        if self.ComputerName == None :
            return "Error: Hostname missing"
        error=WaAgent.EnvMonitor.SetHostName(self.ComputerName)
        if error: return error
        if self.DisableSshPasswordAuthentication:
            filepath = "/etc/ssh/sshd_config"
            # Disable RFC 4252 and RFC 4256 authentication schemes.
            ReplaceFileContentsAtomic(filepath, "\n".join(filter(lambda a: not
                (a.startswith("PasswordAuthentication") or a.startswith("ChallengeResponseAuthentication")),
                GetFileContents(filepath).split('\n'))) + "\nPasswordAuthentication no\nChallengeResponseAuthentication no\n")
            Log("Disabled SSH password-based authentication methods.")
        if self.AdminPassword != None:
            MyDistro.changePass('root',self.AdminPassword)
        if self.UserName != None:
            error = MyDistro.CreateAccount(self.UserName, self.UserPassword, None, None)
        sel = MyDistro.isSelinuxRunning()
        if sel :
            MyDistro.setSelinuxEnforce(0)
        home = MyDistro.GetHome()
        for pkey in self.SshPublicKeys:
            Log("Deploy public key:{0}".format(pkey[0]))
            if not os.path.isfile(pkey[0] + ".crt"):
                Error("PublicKey not found: " + pkey[0])
                error = "Failed to deploy public key (0x09)."
                continue
            path = self.PrepareDir(pkey[1])
            if path == None:
                Error("Invalid path: " + pkey[1] + " for PublicKey: " + pkey[0])
                error = "Invalid path for public key (0x03)."
                continue
            Run(Openssl + " x509 -in " + pkey[0] + ".crt -noout -pubkey > " + pkey[0] + ".pub")
            MyDistro.setSelinuxContext(pkey[0] + '.pub','unconfined_u:object_r:ssh_home_t:s0')
            MyDistro.sshDeployPublicKey(pkey[0] + '.pub',path)
            MyDistro.setSelinuxContext(path,'unconfined_u:object_r:ssh_home_t:s0')
            if path.startswith(os.path.normpath(home + "/" + self.UserName + "/")):
                ChangeOwner(path, self.UserName)
        for keyp in self.SshKeyPairs:
            Log("Deploy key pair:{0}".format(keyp[0]))
            if not os.path.isfile(keyp[0] + ".prv"):
                Error("KeyPair not found: " + keyp[0])
                error = "Failed to deploy key pair (0x0A)."
                continue
            path = self.PrepareDir(keyp[1])
            if path == None:
                Error("Invalid path: " + keyp[1] + " for KeyPair: " + keyp[0])
                error = "Invalid path for key pair (0x05)."
                continue
            SetFileContents(path, GetFileContents(keyp[0] + ".prv"))
            os.chmod(path, 0600)
            Run("ssh-keygen -y -f " + keyp[0] + ".prv > " + path + ".pub")
            MyDistro.setSelinuxContext(path,'unconfined_u:object_r:ssh_home_t:s0')
            MyDistro.setSelinuxContext(path + '.pub','unconfined_u:object_r:ssh_home_t:s0')
            if path.startswith(os.path.normpath(home + "/" + self.UserName + "/")):
                ChangeOwner(path, self.UserName)
                ChangeOwner(path + ".pub", self.UserName)
        if sel :
            MyDistro.setSelinuxEnforce(1)
        while not WaAgent.EnvMonitor.IsHostnamePublished():
            time.sleep(1)
        MyDistro.restartSshService()
        return error

class WALAEvent(object):   
    def __init__(self):
            
        self.providerId=""
        self.eventId=1
        
        self.OpcodeName=""
        self.KeywordName=""
        self.TaskName=""
        self.TenantName=""
        self.RoleName=""
        self.RoleInstanceName=""
        self.ContainerId=""
        self.ExecutionMode="IAAS"
        self.OSVersion=""
        self.GAVersion=""
        self.RAM=0
        self.Processors=0

def ToXml(self):
        strEventid=u'<Event id="{0}"/>'.format(self.eventId)
        strProviderid=u'<Provider id="{0}"/>'.format(self.providerId)
        strRecordFormat = u'<Param Name="{0}" Value="{1}" T="{2}" />'
        strRecordNoQuoteFormat = u'<Param Name="{0}" Value={1} T="{2}" />'
        strMtStr=u'mt:wstr'
        strMtUInt64=u'mt:uint64'
        strMtBool=u'mt:bool'
        strMtFloat=u'mt:float64'
        strEventsData=u""

for attName in  self.__dict__:
            if attName in ["eventId","filedCount","providerId"]:
                continue
            
            attValue = self.__dict__[attName]
            if type(attValue) is int:
                strEventsData+=strRecordFormat.format(attName,attValue,strMtUInt64)
                continue
            if type(attValue) is str:
                attValue = xml.sax.saxutils.quoteattr(attValue)			                
                strEventsData+=strRecordNoQuoteFormat.format(attName,attValue,strMtStr)
                continue
            if str(type(attValue)).count("'unicode'") >0 :
                attValue = xml.sax.saxutils.quoteattr(attValue)			 
                strEventsData+=strRecordNoQuoteFormat.format(attName,attValue,strMtStr)
                continue
            if type(attValue) is bool:
                strEventsData+=strRecordFormat.format(attName,attValue,strMtBool)
                continue
            if type(attValue) is float:
                strEventsData+=strRecordFormat.format(attName,attValue,strMtFloat)
                continue
            
            Log("Warning: property "+attName+":"+str(type(attValue))+":type"+str(type(attValue))+"Can't convert to events data:"+":type not supported")

return u"<Data>{0}{1}{2}</Data>".format(strProviderid,strEventid,strEventsData)

def Save(self):
        eventfolder = LibDir+"/events"
        if not os.path.exists(eventfolder):
            os.mkdir(eventfolder)
            os.chmod(eventfolder,0700)
        if len(os.listdir(eventfolder)) > 1000:
            raise Exception("WriteToFolder:Too many file under "+eventfolder+" exit")
    
        filename = os.path.join(eventfolder,str(int(time.time()*1000000)))
        with open(filename+".tmp",'wb+') as hfile:
            hfile.write(self.ToXml().encode("utf-8"))
        os.rename(filename+".tmp",filename+".tld")

class WALAEventOperation:
    HeartBeat="HeartBeat"
    Provision = "Provision"
    Install = "Install"
    UnIsntall = "UnInstall"
    Disable = "Disable"
    Enable = "Enable"
    Download = "Download"
    Upgrade = "Upgrade"
    Update = "Update"

def AddExtensionEvent(name,op,isSuccess,duration=0,version="1.0",message="",type="",isInternal=False):
    event = ExtensionEvent()
    event.Name=name 
    event.Version=version 
    event.IsInternal=isInternal
    event.Operation=op
    event.OperationSuccess=isSuccess
    event.Message=message 
    event.Duration=duration
    event.ExtensionType=type
    try:
        event.Save()
    except:
        Error("Error "+traceback.format_exc())
        
    
class ExtensionEvent(WALAEvent):
    def __init__(self):
                
        WALAEvent.__init__(self)
        self.eventId=1
        self.providerId="69B669B9-4AF8-4C50-BDC4-6006FA76E975"
        self.Name=""
        self.Version=""
        self.IsInternal=False
        self.Operation=""
        self.OperationSuccess=True
        self.ExtensionType=""
        self.Message=""
        self.Duration=0
    
               		           
class WALAEventMonitor(WALAEvent):
    def __init__(self,postMethod):
        WALAEvent.__init__(self)
        self.post = postMethod
        self.sysInfo={}
        self.eventdir = LibDir+"/events"
        self.issysteminfoinitilized = False

def StartEventsLoop(self):
        eventThread = threading.Thread(target = self.EventsLoop)
        eventThread.setDaemon(True)
        eventThread.start()
        
    def EventsLoop(self):
        LastReportHeartBeatTime = datetime.datetime.min
        try:
            while True:
                if (datetime.datetime.now()-LastReportHeartBeatTime) > \
                        datetime.timedelta(minutes=30):
                    LastReportHeartBeatTime = datetime.datetime.now()
                    AddExtensionEvent(op=WALAEventOperation.HeartBeat,name="WALA",isSuccess=True)
                self.postNumbersInOneLoop=0
                self.CollectAndSendWALAEvents()
                time.sleep(60)
        except:
            Error("Exception in events loop:"+traceback.format_exc())
			     		    		
    def SendEvent(self,providerid,events):
        dataFormat = u'<?xml version="1.0"?><TelemetryData version="1.0"><Provider id="{0}">{1}'\
        '</Provider></TelemetryData>'
        data = dataFormat.format(providerid,events)
        self.post("/machine/?comp=telemetrydata", data)

def CollectAndSendWALAEvents(self):        
        if not os.path.exists(self.eventdir):
            return
        #Throtting, can't send more than 3 events in 15 seconds  
        eventSendNumber=0
        eventFiles = os.listdir(self.eventdir)
        events = {}
        for file in eventFiles:
            if not file.endswith(".tld"):
                continue      
            with open(os.path.join(self.eventdir,file),"rb") as hfile:
            #if fail to open or delete the file, throw exception 
                xmlStr = hfile.read().decode("utf-8",'ignore')
            os.remove(os.path.join(self.eventdir,file))
            params=""
            eventid=""
            providerid=""
            #if exception happen during process an event, catch it and continue
            try:
                xmlStr = self.AddSystemInfo(xmlStr)
                for node in xml.dom.minidom.parseString(xmlStr.encode("utf-8")).childNodes[0].childNodes:
                    if node.tagName == "Param":
                        params+=node.toxml()
                    if node.tagName == "Event":
                        eventid=node.getAttribute("id")
                    if node.tagName == "Provider":
                        providerid = node.getAttribute("id")
            except:
                Error(traceback.format_exc())
                continue
            if len(params)==0 or len(eventid)==0 or len(providerid)==0:
                Error("Empty filed in params:"+params+" event id:"+eventid+" provider id:"+providerid)
                continue

eventstr = u'<Event id="{0}"><![CDATA[{1}]]></Event>'.format(eventid,params)
            if not events.get(providerid):
                events[providerid]=""
            if len(events[providerid]) >0 and  len(events.get(providerid)+eventstr)>= 63*1024:
                eventSendNumber+=1
                self.SendEvent(providerid,events.get(providerid))
                if eventSendNumber %3 ==0:
                    time.sleep(15)
                events[providerid]=""
            if len(eventstr) >= 63*1024:
                Error("Signle event too large abort "+eventstr[:300])
                continue

events[providerid]=events.get(providerid)+eventstr

for key in events.keys():
            if len(events[key]) > 0:
                eventSendNumber+=1
                self.SendEvent(key,events[key])
                if eventSendNumber%3 == 0:
                    time.sleep(15)

def AddSystemInfo(self,eventData):
        if not self.issysteminfoinitilized:
            self.issysteminfoinitilized=True
            try:
                self.sysInfo["OSVersion"]=platform.system()+":"+"-".join(DistInfo(1))+":"+platform.release()
                self.sysInfo["GAVersion"]=GuestAgentVersion
                self.sysInfo["RAM"]=MyDistro.getTotalMemory()
                self.sysInfo["Processors"]=MyDistro.getProcessorCores()
                sharedConfig = xml.dom.minidom.parse("/var/lib/waagent/SharedConfig.xml").childNodes[0]
                hostEnvConfig= xml.dom.minidom.parse("/var/lib/waagent/HostingEnvironmentConfig.xml").childNodes[0]
                gfiles = RunGetOutput("ls -t /var/lib/waagent/GoalState.*.xml")[1]
                goalStateConfi =  xml.dom.minidom.parse(gfiles.split("\n")[0]).childNodes[0]
                self.sysInfo["TenantName"]=hostEnvConfig.getElementsByTagName("Deployment")[0].getAttribute("name")
                self.sysInfo["RoleName"]=hostEnvConfig.getElementsByTagName("Role")[0].getAttribute("name")
                self.sysInfo["RoleInstanceName"]=sharedConfig.getElementsByTagName("Instance")[0].getAttribute("id")
                self.sysInfo["ContainerId"]=goalStateConfi.getElementsByTagName("ContainerId")[0].childNodes[0].nodeValue
            except:
                Error(traceback.format_exc())

eventObject = xml.dom.minidom.parseString(eventData.encode("utf-8")).childNodes[0]
        for node in eventObject.childNodes:
            if node.tagName == "Param":
                name = node.getAttribute("Name")
                if self.sysInfo.get(name):
                    node.setAttribute("Value",xml.sax.saxutils.escape(str(self.sysInfo[name])))

return  eventObject.toxml()

class Agent(Util):
    """
    Primary object container for the provisioning process.
    
    """
    def __init__(self):
        self.GoalState = None
        self.Endpoint = None
        self.LoadBalancerProbeServer = None
        self.HealthReportCounter = 0
        self.TransportCert = ""
        self.EnvMonitor = None
        self.SendData = None
        self.DhcpResponse = None

def CheckVersions(self):
        """
        Query endpoint server for wire protocol version.
        Fail if our desired protocol version is not seen.
        """
        #<?xml version="1.0" encoding="utf-8"?>
        #<Versions>
        #  <Preferred>
        #    <Version>2010-12-15</Version>
        #  </Preferred>
        #  <Supported>
        #    <Version>2010-12-15</Version>
        #    <Version>2010-28-10</Version>
        #  </Supported>
        #</Versions>
        global ProtocolVersion
        protocolVersionSeen = False
        node = xml.dom.minidom.parseString(self.HttpGetWithoutHeaders("/?comp=versions")).childNodes[0]
        if node.localName != "Versions":
            Error("CheckVersions: root not Versions")
            return False
        for a in node.childNodes:
            if a.nodeType == node.ELEMENT_NODE and a.localName == "Supported":
                for b in a.childNodes:
                    if b.nodeType == node.ELEMENT_NODE and b.localName == "Version":
                        v = GetNodeTextData(b)
                        LogIfVerbose("Fabric supported wire protocol version: " + v)
                        if v == ProtocolVersion:
                            protocolVersionSeen = True
            if a.nodeType == node.ELEMENT_NODE and a.localName == "Preferred":
                v = GetNodeTextData(a.getElementsByTagName("Version")[0])
                Log("Fabric preferred wire protocol version: " + v)
        if not protocolVersionSeen:
            Warn("Agent supported wire protocol version: " + ProtocolVersion + " was not advertised by Fabric.")
        else:
            Log("Negotiated wire protocol version: " + ProtocolVersion)
        return True

def Unpack(self, buffer, offset, range):
        """
        Unpack bytes into python values.
        """
        result = 0
        for i in range:
            result = (result << 8) | Ord(buffer[offset + i])
        return result

def UnpackLittleEndian(self, buffer, offset, length):
        """
        Unpack little endian bytes into python values.
        """
        return self.Unpack(buffer, offset, list(range(length - 1, -1, -1)))

def UnpackBigEndian(self, buffer, offset, length):
        """
        Unpack big endian bytes into python values.
        """
        return self.Unpack(buffer, offset, list(range(0, length)))

def HexDump3(self, buffer, offset, length):
        """
        Dump range of buffer in formatted hex.
        """
        return ''.join(['%02X' % Ord(char) for char in buffer[offset:offset + length]])

def HexDump2(self, buffer):
        """
        Dump buffer in formatted hex.
        """
        return self.HexDump3(buffer, 0, len(buffer))

def BuildDhcpRequest(self):
        """
        Build DHCP request string.
        """
        #
        # typedef struct _DHCP {
        #     UINT8   Opcode;                     /* op:     BOOTREQUEST or BOOTREPLY */
        #     UINT8   HardwareAddressType;        /* htype:  ethernet */
        #     UINT8   HardwareAddressLength;      /* hlen:   6 (48 bit mac address) */
        #     UINT8   Hops;                       /* hops:   0 */
        #     UINT8   TransactionID[4];           /* xid:    random */
        #     UINT8   Seconds[2];                 /* secs:   0 */
        #     UINT8   Flags[2];                   /* flags:  0 or 0x8000 for broadcast */
        #     UINT8   ClientIpAddress[4];         /* ciaddr: 0 */
        #     UINT8   YourIpAddress[4];           /* yiaddr: 0 */
        #     UINT8   ServerIpAddress[4];         /* siaddr: 0 */
        #     UINT8   RelayAgentIpAddress[4];     /* giaddr: 0 */
        #     UINT8   ClientHardwareAddress[16];  /* chaddr: 6 byte ethernet MAC address */
        #     UINT8   ServerName[64];             /* sname:  0 */
        #     UINT8   BootFileName[128];          /* file:   0  */
        #     UINT8   MagicCookie[4];             /*   99  130   83   99 */
        #                                         /* 0x63 0x82 0x53 0x63 */
        #     /* options -- hard code ours */
        #
        #     UINT8 MessageTypeCode;              /* 53 */
        #     UINT8 MessageTypeLength;            /* 1 */
        #     UINT8 MessageType;                  /* 1 for DISCOVER */
        #     UINT8 End;                          /* 255 */
        # } DHCP;
        #

# tuple of 244 zeros
        # (struct.pack_into would be good here, but requires Python 2.5)
        sendData = [0] * 244

transactionID = os.urandom(4)
        macAddress = MyDistro.GetMacAddress()

# Opcode = 1
        # HardwareAddressType = 1 (ethernet/MAC)
        # HardwareAddressLength = 6 (ethernet/MAC/48 bits)
        for a in range(0, 3):
            sendData[a] = [1, 1, 6][a]

# fill in transaction id (random number to ensure response matches request)
        for a in range(0, 4):
            sendData[4 + a] = Ord(transactionID[a])

LogIfVerbose("BuildDhcpRequest: transactionId:%s,%04X" % (self.HexDump2(transactionID), self.UnpackBigEndian(sendData, 4, 4)))

# fill in ClientHardwareAddress
        for a in range(0, 6):
            sendData[0x1C + a] = Ord(macAddress[a])

# DHCP Magic Cookie: 99, 130, 83, 99
        # MessageTypeCode = 53 DHCP Message Type
        # MessageTypeLength = 1
        # MessageType = DHCPDISCOVER
        # End = 255 DHCP_END
        for a in range(0, 8):
            sendData[0xEC + a] = [99, 130, 83, 99, 53, 1, 1, 255][a]
        return array.array("B", sendData)

def IntegerToIpAddressV4String(self, a):
        """
        Build DHCP request string.
        """
        return "%u.%u.%u.%u" % ((a >> 24) & 0xFF, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF)

def RouteAdd(self, net, mask, gateway):
        """
        Add specified route using /sbin/route add -net.
        """
        net = self.IntegerToIpAddressV4String(net)
        mask = self.IntegerToIpAddressV4String(mask)
        gateway = self.IntegerToIpAddressV4String(gateway)
        Log("Route add: net={0}, mask={1}, gateway={2}".format(net, mask, gateway))
        MyDistro.routeAdd(net, mask, gateway)
    
    def SetDefaultGateway(self, gateway):
        """
        Set default gateway
        """
        gateway = self.IntegerToIpAddressV4String(gateway)
        Log("Set default gateway: {0}".format(gateway))
        MyDistro.setDefaultGateway(gateway)

def HandleDhcpResponse(self, sendData, receiveBuffer):
        """
        Parse DHCP response:
        Set default gateway.
        Set default routes.
        Retrieve endpoint server.
        Returns endpoint server or None on error.
        """
        LogIfVerbose("HandleDhcpResponse")
        bytesReceived = len(receiveBuffer)
        if bytesReceived < 0xF6:
            Error("HandleDhcpResponse: Too few bytes received " + str(bytesReceived))
            return None

LogIfVerbose("BytesReceived: " + hex(bytesReceived))
        LogWithPrefixIfVerbose("DHCP response:", HexDump(receiveBuffer, bytesReceived))

# check transactionId, cookie, MAC address
        # cookie should never mismatch
        # transactionId and MAC address may mismatch if we see a response meant from another machine

for offsets in [list(range(4, 4 + 4)), list(range(0x1C, 0x1C + 6)), list(range(0xEC, 0xEC + 4))]:
            for offset in offsets:
                sentByte = Ord(sendData[offset])
                receivedByte = Ord(receiveBuffer[offset])
                if sentByte != receivedByte:
                    LogIfVerbose("HandleDhcpResponse: sent cookie:" + self.HexDump3(sendData, 0xEC, 4))
                    LogIfVerbose("HandleDhcpResponse: rcvd cookie:" + self.HexDump3(receiveBuffer, 0xEC, 4))
                    LogIfVerbose("HandleDhcpResponse: sent transactionID:" + self.HexDump3(sendData, 4, 4))
                    LogIfVerbose("HandleDhcpResponse: rcvd transactionID:" + self.HexDump3(receiveBuffer, 4, 4))
                    LogIfVerbose("HandleDhcpResponse: sent ClientHardwareAddress:" + self.HexDump3(sendData, 0x1C, 6))
                    LogIfVerbose("HandleDhcpResponse: rcvd ClientHardwareAddress:" + self.HexDump3(receiveBuffer, 0x1C, 6))
                    LogIfVerbose("HandleDhcpResponse: transactionId, cookie, or MAC address mismatch")
                    return None
        endpoint = None

#
        # Walk all the returned options, parsing out what we need, ignoring the others.
        # We need the custom option 245 to find the the endpoint we talk to,
        # as well as, to handle some Linux DHCP client incompatibilities,
        # options 3 for default gateway and 249 for routes. And 255 is end.
        #

i = 0xF0 # offset to first option
        while i < bytesReceived:
            option = Ord(receiveBuffer[i])
            length = 0
            if (i + 1) < bytesReceived:
                length = Ord(receiveBuffer[i + 1])
            LogIfVerbose("DHCP option " + hex(option) + " at offset:" + hex(i) + " with length:" + hex(length))
            if option == 255:
                LogIfVerbose("DHCP packet ended at offset " + hex(i))
                break
            elif option == 249:
                # http://msdn.microsoft.com/en-us/library/cc227282%28PROT.10%29.aspx
                LogIfVerbose("Routes at offset:" + hex(i) + " with length:" + hex(length))
                if length < 5:
                    Error("Data too small for option " + str(option))
                j = i + 2
                while j < (i + length + 2):
                    maskLengthBits = Ord(receiveBuffer[j])
                    maskLengthBytes = (((maskLengthBits + 7) & ~7) >> 3)
                    mask = 0xFFFFFFFF & (0xFFFFFFFF << (32 - maskLengthBits))
                    j += 1
                    net = self.UnpackBigEndian(receiveBuffer, j, maskLengthBytes)
                    net <<= (32 - maskLengthBytes * 8)
                    net &= mask
                    j += maskLengthBytes
                    gateway = self.UnpackBigEndian(receiveBuffer, j, 4)
                    j += 4
                    self.RouteAdd(net, mask, gateway)
                if j != (i + length + 2):
                    Error("HandleDhcpResponse: Unable to parse routes")
            elif option == 3 or option == 245:
                if i + 5 < bytesReceived:
                    if length != 4:
                        Error("HandleDhcpResponse: Endpoint or Default Gateway not 4 bytes")
                        return None
                    gateway = self.UnpackBigEndian(receiveBuffer, i + 2, 4)
                    IpAddress = self.IntegerToIpAddressV4String(gateway)
                    if option == 3:
                        self.SetDefaultGateway(gateway)
                        name = "DefaultGateway"
                    else:
                        endpoint = IpAddress
                        name = "Azure wire protocol endpoint"
                    LogIfVerbose(name + ": " + IpAddress + " at " + hex(i))
                else:
                    Error("HandleDhcpResponse: Data too small for option " + str(option))
            else:
                LogIfVerbose("Skipping DHCP option " + hex(option) + " at " + hex(i) + " with length " + hex(length))
            i += length + 2
        return endpoint

def DoDhcpWork(self):
        """
        Discover the wire server via DHCP option 245.
        And workaround incompatibility with Azure DHCP servers.
        """
        ShortSleep = False # Sleep 1 second before retrying DHCP queries.
        ifname=None

sleepDurations = [0, 10, 30, 60, 60]
        maxRetry = len(sleepDurations)
        lastTry = (maxRetry - 1)
        for retry in range(0, maxRetry):
            try:
                #Open DHCP port if iptables is enabled.
                Run("iptables -D INPUT -p udp --dport 68 -j ACCEPT",chk_err=False)  # We supress error logging on error.
                Run("iptables -I INPUT -p udp --dport 68 -j ACCEPT",chk_err=False)  # We supress error logging on error.
                strRetry = str(retry)
                prefix = "DoDhcpWork: try=" + strRetry
                LogIfVerbose(prefix)
                sendData = self.BuildDhcpRequest()
                LogWithPrefixIfVerbose("DHCP request:", HexDump(sendData, len(sendData)))
                sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
                sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
                sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
                missingDefaultRoute = True
                try:
                    if DistInfo()[0] == 'FreeBSD':
                        missingDefaultRoute = True
                    else:
                        routes = RunGetOutput("route -n")[1]
                    for line in routes.split('\n'):
                        if line.startswith("0.0.0.0 ") or line.startswith("default "):
                            missingDefaultRoute = False
                except:
                    pass
                if missingDefaultRoute:
                    # This is required because sending after binding to 0.0.0.0 fails with
                    # network unreachable when the default gateway is not set up.
                    ifname=MyDistro.GetInterfaceName()
                    Log("DoDhcpWork: Missing default route - adding broadcast route for DHCP.")
                    if DistInfo()[0] == 'FreeBSD':
                        Run("route add -net 255.255.255.255 -iface " + ifname,chk_err=False)
                    else:
                        Run("route add 255.255.255.255 dev " + ifname,chk_err=False)
                if MyDistro.isDHCPEnabled():
                    MyDistro.stopDHCP()
                sock.bind(("0.0.0.0", 68)) 
                sock.sendto(sendData, ("<broadcast>", 67))
                sock.settimeout(10)
                Log("DoDhcpWork: Setting socket.timeout=10, entering recv")
                receiveBuffer = sock.recv(1024)
                endpoint = self.HandleDhcpResponse(sendData, receiveBuffer)
                if endpoint == None:
                    LogIfVerbose("DoDhcpWork: No endpoint found")
                if endpoint != None or retry == lastTry:
                    if endpoint != None:
                        self.SendData = sendData
                        self.DhcpResponse = receiveBuffer
                    if retry == lastTry:
                        LogIfVerbose("DoDhcpWork: try=" + strRetry)
                    return endpoint
                sleepDuration = [sleepDurations[retry % len(sleepDurations)], 1][ShortSleep]
                LogIfVerbose("DoDhcpWork: sleep=" + str(sleepDuration))
                time.sleep(sleepDuration)
            except Exception, e:
                ErrorWithPrefix(prefix, str(e))
                ErrorWithPrefix(prefix, traceback.format_exc())
            finally:
                sock.close()
                if missingDefaultRoute:
                    #We added this route - delete it
                    Log("DoDhcpWork: Removing broadcast route for DHCP.")
                    if DistInfo()[0] == 'FreeBSD':
                        Run("route del -net 255.255.255.255 -iface " + ifname,chk_err=False)
                    else:
                        Run("route del 255.255.255.255 dev " + ifname,chk_err=False)  # We supress error logging on error.
                if MyDistro.isDHCPEnabled():
                    MyDistro.startDHCP()
        return None

def UpdateAndPublishHostName(self, name):
        """
        Set hostname locally and publish to iDNS
        """
        Log("Setting host name: " + name)
        MyDistro.publishHostname(name)
        ethernetInterface = MyDistro.GetInterfaceName()
        MyDistro.RestartInterface(ethernetInterface)
        self.RestoreRoutes()

def RestoreRoutes(self):
        """
        If there is a DHCP response, then call HandleDhcpResponse.
        """
        if self.SendData != None and self.DhcpResponse != None:
            self.HandleDhcpResponse(self.SendData, self.DhcpResponse)

def UpdateGoalState(self):
        """
        Retreive goal state information from endpoint server.
        Parse xml and initialize Agent.GoalState object.
        Return object or None on error.
        """
        goalStateXml = None
        maxRetry = 9
        log = NoLog
        for retry in range(1, maxRetry + 1):
            strRetry = str(retry)
            log("retry UpdateGoalState,retry=" + strRetry)
            goalStateXml = self.HttpGetWithHeaders("/machine/?comp=goalstate")
            if goalStateXml != None:
                break
            log = Log
            time.sleep(retry)
        if not goalStateXml:
            Error("UpdateGoalState failed.")
            return
        Log("Retrieved GoalState from Azure Fabric.")
        self.GoalState = GoalState(self).Parse(goalStateXml)
        return self.GoalState

def ReportReady(self):
        """
        Send health report 'Ready' to server.
        This signals the fabric that our provosion is completed,
        and the host is ready for operation.
        """
        counter = (self.HealthReportCounter + 1) % 1000000
        self.HealthReportCounter = counter
        healthReport = ("<?xml version=\"1.0\" encoding=\"utf-8\"?><Health xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"><GoalStateIncarnation>"
                        + self.GoalState.Incarnation
                        + "</GoalStateIncarnation><Container><ContainerId>"
                        + self.GoalState.ContainerId
                        + "</ContainerId><RoleInstanceList><Role><InstanceId>"
                        + self.GoalState.RoleInstanceId
                        + "</InstanceId><Health><State>Ready</State></Health></Role></RoleInstanceList></Container></Health>")
        a = self.HttpPostWithHeaders("/machine?comp=health", healthReport)
        if a != None:
            return a.getheader("x-ms-latest-goal-state-incarnation-number")
        return None

def ReportNotReady(self, status, desc):
        """
        Send health report 'Provisioning' to server.
        This signals the fabric that our provosion is starting.
        """
        healthReport = ("<?xml version=\"1.0\" encoding=\"utf-8\"?><Health xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"><GoalStateIncarnation>"
                        + self.GoalState.Incarnation
                        + "</GoalStateIncarnation><Container><ContainerId>"
                        + self.GoalState.ContainerId
                        + "</ContainerId><RoleInstanceList><Role><InstanceId>"
                        + self.GoalState.RoleInstanceId
                        + "</InstanceId><Health><State>NotReady</State>"
                        + "<Details><SubStatus>" + status + "</SubStatus><Description>" + desc + "</Description></Details>"
                        + "</Health></Role></RoleInstanceList></Container></Health>")
        a = self.HttpPostWithHeaders("/machine?comp=health", healthReport)
        if a != None:
            return a.getheader("x-ms-latest-goal-state-incarnation-number")
        return None

def ReportRoleProperties(self, thumbprint):
        """
        Send roleProperties and thumbprint to server. 
        """
        roleProperties = ("<?xml version=\"1.0\" encoding=\"utf-8\"?><RoleProperties><Container>"
                        + "<ContainerId>" + self.GoalState.ContainerId + "</ContainerId>"
                        + "<RoleInstances><RoleInstance>"
                        + "<Id>" + self.GoalState.RoleInstanceId + "</Id>"
                        + "<Properties><Property name=\"CertificateThumbprint\" value=\"" + thumbprint + "\" /></Properties>"
                        + "</RoleInstance></RoleInstances></Container></RoleProperties>")
        a = self.HttpPostWithHeaders("/machine?comp=roleProperties", 
                                     roleProperties)
        Log("Posted Role Properties. CertificateThumbprint=" + thumbprint)
        return a

def LoadBalancerProbeServer_Shutdown(self):
        """
        Shutdown the LoadBalancerProbeServer.
        """
        if self.LoadBalancerProbeServer != None:
            self.LoadBalancerProbeServer.shutdown()
            self.LoadBalancerProbeServer = None

def GenerateTransportCert(self):
        """
        Create ssl certificate for https communication with endpoint server.
        """
        Run(Openssl + " req -x509 -nodes -subj /CN=LinuxTransport -days 32768 -newkey rsa:2048 -keyout TransportPrivate.pem -out TransportCert.pem")
        cert = ""
        for line in GetFileContents("TransportCert.pem").split('\n'):
            if not "CERTIFICATE" in line:
                cert += line.rstrip()
        return cert

def DoVmmStartup(self):
        """
        Spawn the VMM startup script.
        """
        Log("Starting Microsoft System Center VMM Initialization Process")
        pid = subprocess.Popen(["/bin/bash","/mnt/cdrom/secure/"+VMM_STARTUP_SCRIPT_NAME,"-p /mnt/cdrom/secure/ "]).pid
        time.sleep(5)
        sys.exit(0)
        
    def TryUnloadAtapiix(self):
        """
        If global modloaded is True, then we loaded the ata_piix kernel module, unload it.
        """
        if modloaded:
            Run("rmmod ata_piix.ko",chk_err=False)
            Log("Unloaded ata_piix.ko driver for ATAPI CD-ROM")

def TryLoadAtapiix(self):
        """
        Load the ata_piix kernel module if it exists.
        If successful, set global modloaded to True.
        If unable to load module leave modloaded False.
        """
        global modloaded
        modloaded=False
        retcode,krn=RunGetOutput('uname -r')
        krn_pth='/lib/modules/'+krn.strip('\n')+'/kernel/drivers/ata/ata_piix.ko'
        if Run("lsmod | grep ata_piix",chk_err=False) == 0 :
            Log("Module " + krn_pth + " driver for ATAPI CD-ROM is already present.")
            return 0
        if retcode:
            Error("Unable to provision: Failed to call uname -r")
            return "Unable to provision: Failed to call uname"
        if os.path.isfile(krn_pth):
            retcode,output=RunGetOutput("insmod " + krn_pth,chk_err=False)
        else:
            Log("Module " + krn_pth + " driver for ATAPI CD-ROM does not exist.")
            return 1
        if retcode != 0:
            Error('Error calling insmod for '+ krn_pth + ' driver for ATAPI CD-ROM')
            return retcode
        time.sleep(1)
        # check 3 times if the mod is loaded
        for i in range(3):
            if Run('lsmod | grep ata_piix'):
                continue
            else :
                modloaded=True
                break
        if not modloaded:
            Error('Unable to load '+ krn_pth + ' driver for ATAPI CD-ROM')
            return 1
        
        Log("Loaded " + krn_pth + " driver for ATAPI CD-ROM")
        
        # we have succeeded loading the ata_piix mod if it can be done.

def SearchForVMMStartup(self):
        """
        Search for a DVD/CDROM containing VMM's VMM_CONFIG_FILE_NAME.
        Call TryLoadAtapiix in case we must load the ata_piix module first.

If VMM_CONFIG_FILE_NAME is found, call DoVmmStartup.
        Else, return to Azure Provisioning process.
        """
        self.TryLoadAtapiix()
        if os.path.exists('/mnt/cdrom/secure') == False:
            CreateDir("/mnt/cdrom/secure", "root", 0700)
        mounted=False
        for dvds in [re.match(r'(sr[0-9]|hd[c-z]|cdrom[0-9]|cd[0-9]?)',x) for x in os.listdir('/dev/')]:
            if dvds == None:
                continue
            dvd = '/dev/'+dvds.group(0)
            if Run("LC_ALL=C fdisk -l " + dvd + " | grep Disk",chk_err=False):
                continue  # Not mountable
            else:
                for retry in range(1,6):
                    retcode,output=RunGetOutput("mount -v " + dvd + " /mnt/cdrom/secure")
                    Log(output[:-1])
                    if retcode == 0:
                        Log("mount succeeded on attempt #" + str(retry) )
                        mounted=True
                        break
                    if 'is already mounted on /mnt/cdrom/secure' in output:
                        Log("Device " + dvd + " is already mounted on /mnt/cdrom/secure." + str(retry) )
                        mounted=True
                        break
                    Log("mount failed on attempt #" + str(retry) )
                    Log("mount loop sleeping 5...")
                    time.sleep(5)
                if not mounted:
                    # unable to mount
                    continue
                if not os.path.isfile("/mnt/cdrom/secure/"+VMM_CONFIG_FILE_NAME):
                    #nope - mount the next drive
                    if mounted:
                        Run("umount "+dvd,chk_err=False)
                        mounted=False
                        continue
                else : # it is the vmm startup
                    self.DoVmmStartup()

Log("VMM Init script not found.  Provisioning for Azure")
        return 
        
    def Provision(self):
        """
        Responible for:
        Regenerate ssh keys,
        Mount, read, and parse ovfenv.xml from provisioning dvd rom
        Process the ovfenv.xml info
        Call ReportRoleProperties
        If configured, delete root password.
        Return None on success, error string on error.
        """
        enabled = Config.get("Provisioning.Enabled")
        if enabled != None and enabled.lower().startswith("n"):
            return
        Log("Provisioning image started.")
        type = Config.get("Provisioning.SshHostKeyPairType")
        if type == None:
            type = "rsa"
        regenerateKeys = Config.get("Provisioning.RegenerateSshHostKeyPair")
        if regenerateKeys == None or regenerateKeys.lower().startswith("y"):
            Run("rm -f /etc/ssh/ssh_host_*key*")
            Run("ssh-keygen -N '' -t " + type + " -f /etc/ssh/ssh_host_" + type + "_key")
            MyDistro.restartSshService()
        #SetFileContents(LibDir + "/provisioned", "")
        dvd = None
        for dvds in [re.match(r'(sr[0-9]|hd[c-z]|cdrom[0-9]|cd[0-9]?)',x) for x in os.listdir('/dev/')]:
            if dvds == None :
                continue
            dvd = '/dev/'+dvds.group(0)
        if dvd == None:
            # No DVD device detected
            Error("No DVD device detected, unable to provision.")
            return "No DVD device detected, unable to provision."
        if MyDistro.mediaHasFilesystem(dvd) is False :
            out=MyDistro.load_ata_piix()
            if out:
                return out
            for i in range(10): # we may have to wait 
                if os.path.exists(dvd):
                    break
                Log("Waiting for DVD - sleeping 1 - "+str(i+1)+" try...")
                time.sleep(1)
        if os.path.exists('/mnt/cdrom/secure') == False:
            CreateDir("/mnt/cdrom/secure", "root", 0700)
        #begin mount loop - 5 tries - 5 sec wait between
        for retry in range(1,6):
            location='/mnt/cdrom/secure'
            retcode,output=MyDistro.mountDVD(dvd,location)
            Log(output[:-1])
            if retcode == 0:
                Log("mount succeeded on attempt #" + str(retry) )
                break
            if 'is already mounted on /mnt/cdrom/secure' in output:
                Log("Device " + dvd + " is already mounted on /mnt/cdrom/secure." + str(retry) )
                break
            Log("mount failed on attempt #" + str(retry) )
            Log("mount loop sleeping 5...")
            time.sleep(5)
        if not os.path.isfile("/mnt/cdrom/secure/ovf-env.xml"):
            Error("Unable to provision: Missing ovf-env.xml on DVD.")
            return "Failed to retrieve provisioning data (0x02)."
        ovfxml = (GetFileContents(u"/mnt/cdrom/secure/ovf-env.xml",asbin=False)) # use unicode here to ensure correct codec gets used.
        if ord(ovfxml[0]) > 128 and ord(ovfxml[1]) > 128 and ord(ovfxml[2]) > 128 :
            ovfxml = ovfxml[3:] # BOM is not stripped.  First three bytes are > 128 and not unicode chars so we ignore them.
        ovfxml=ovfxml.strip(chr(0x00)) # we may have NULLs.
        ovfxml=ovfxml[ovfxml.find('<?'):] # chop leading text if present
        SetFileContents("ovf-env.xml", re.sub("<UserPassword>.*?<", "<UserPassword>*<", ovfxml))
        Run("umount " + dvd,chk_err=False)
        MyDistro.unload_ata_piix()
        error = None
        if ovfxml != None:
            Log("Provisioning image using OVF settings in the DVD.")
            ovfobj = OvfEnv().Parse(ovfxml)
            if ovfobj != None:
                error = ovfobj.Process()
                if error :
                    Error ("Provisioning image FAILED " + error)
                    return ("Provisioning image FAILED " + error)
            Log("Ovf XML process finished")
        # This is done here because regenerated SSH host key pairs may be potentially overwritten when processing the ovfxml
        fingerprint = RunGetOutput("ssh-keygen -lf /etc/ssh/ssh_host_" + type + "_key.pub")[1].rstrip().split()[1].replace(':','')
        self.ReportRoleProperties(fingerprint)
        delRootPass = Config.get("Provisioning.DeleteRootPassword")
        if delRootPass != None and delRootPass.lower().startswith("y"):
            MyDistro.deleteRootPassword()
        Log("Provisioning image completed.")
        return error

def Run(self):
        """
        Called by 'waagent -daemon.'
        Main loop to process the goal state.  State is posted every 25 seconds
        when provisioning has been completed.
        
        Search for VMM enviroment, start VMM script if found.
        Perform DHCP and endpoint server discovery by calling DoDhcpWork().
        Check wire protocol versions.
        Set SCSI timeout on root device.
        Call GenerateTransportCert() to create ssl certs for server communication.
        Call UpdateGoalState().
        If not provisioned, call ReportNotReady("Provisioning", "Starting")
        Call Provision(), set global provisioned = True if successful.
        Call goalState.Process()
        Start LBProbeServer if indicated in waagent.conf.
        Start the StateConsumer if indicated in waagent.conf.
        ReportReady if provisioning is complete.
        If provisioning failed, call ReportNotReady("ProvisioningFailed", provisionError)
        """
        SetFileContents("/var/run/waagent.pid", str(os.getpid()) + "\n")

reportHandlerStatusCount = 0

# Determine if we are in VMM.  Spawn VMM_STARTUP_SCRIPT_NAME if found.
        self.SearchForVMMStartup()
        ipv4=''
        while ipv4 == '' or ipv4 == '0.0.0.0' :
            ipv4=MyDistro.GetIpv4Address()
            if ipv4 == '' or ipv4 == '0.0.0.0' :
                Log("Waiting for network.")
                time.sleep(10)

Log("IPv4 address: " + ipv4)
        mac=''
        mac=MyDistro.GetMacAddress()
        if len(mac)>0 :
            Log("MAC  address: " + ":".join(["%02X" % Ord(a) for a in mac]))
        
        # Consume Entropy in ACPI table provided by Hyper-V
        try:
            SetFileContents("/dev/random", GetFileContents("/sys/firmware/acpi/tables/OEM0"))
        except:
            pass

Log("Probing for Azure environment.")
        self.Endpoint = self.DoDhcpWork()

while self.Endpoint == None:
            Log("Azure environment not detected.")
            Log("Retry environment detection in 60 seconds")
            time.sleep(60)
            self.Endpoint = self.DoDhcpWork()

Log("Discovered Azure endpoint: " + self.Endpoint)
        if not self.CheckVersions():
            Error("Agent.CheckVersions failed")
            sys.exit(1)

self.EnvMonitor = EnvMonitor()

# Set SCSI timeout on SCSI disks
        MyDistro.initScsiDiskTimeout()
        global provisioned
        global provisionError
        
        global Openssl
        Openssl = Config.get("OS.OpensslPath")
        if Openssl == None:
            Openssl = "openssl"

self.TransportCert = self.GenerateTransportCert()
        
        eventMonitor = None
        incarnation = None # goalStateIncarnationFromHealthReport
        currentPort = None # loadBalancerProbePort
        goalState = None # self.GoalState, instance of GoalState
        provisioned = os.path.exists(LibDir + "/provisioned")
        program = Config.get("Role.StateConsumer")
        provisionError = None        
        lbProbeResponder = True
        setting = Config.get("LBProbeResponder")
        if setting != None and setting.lower().startswith("n"):
            lbProbeResponder = False
        while True:
            if (goalState == None) or (incarnation == None) or (goalState.Incarnation != incarnation):
                try:
                    goalState = self.UpdateGoalState()
                except HttpResourceGoneError as e:
                    Warn("Incarnation is out of date:{0}".format(e))
                    incarnation = None
                    continue

if goalState == None :
                    Warn("Failed to fetch goalstate")
                    continue

if provisioned == False:
                    self.ReportNotReady("Provisioning", "Starting")

goalState.Process()

if provisioned == False:
                    provisionError = self.Provision()
                    if provisionError == None :
                        provisioned = True
                        SetFileContents(LibDir + "/provisioned", "")
                        lastCtime = "NOTFIND"
                        try:
                            walaConfigFile = MyDistro.getConfigurationPath()
                            lastCtime = time.ctime(os.path.getctime(walaConfigFile))
                        except:
                            pass
                        #Get Ctime of wala config, can help identify the base image of this VM
                        AddExtensionEvent(name="WALA",op=WALAEventOperation.Provision,isSuccess=True,
                                              message="WALA Config Ctime:"+lastCtime)

executeCustomData = Config.get("Provisioning.ExecuteCustomData")
                        if executeCustomData != None and executeCustomData.lower().startswith("y"):
                          if os.path.exists(LibDir + '/CustomData'):
                            Run('chmod +x ' + LibDir + '/CustomData')
                            Run(LibDir + '/CustomData')
                          else:
                            Error(LibDir + '/CustomData does not exist.')

#
                # only one port supported
                # restart server if new port is different than old port
                # stop server if no longer a port
                #
                goalPort = goalState.LoadBalancerProbePort
                if currentPort != goalPort:
                    try:
                        self.LoadBalancerProbeServer_Shutdown()
                        currentPort = goalPort
                        if currentPort != None and lbProbeResponder == True:
                            self.LoadBalancerProbeServer = LoadBalancerProbeServer(currentPort)
                            if self.LoadBalancerProbeServer == None :
                                lbProbeResponder = False
                                Log("Unable to create LBProbeResponder.")
                    except Exception, e:
                        Error("Failed to launch LBProbeResponder: {0}".format(e))
                        currentPort = None

# Report SSH key fingerprint
                type = Config.get("Provisioning.SshHostKeyPairType")
                if type == None:
                    type = "rsa"

host_key_path = "/etc/ssh/ssh_host_" + type + "_key.pub"
                if(MyDistro.waitForSshHostKey(host_key_path)):
                    fingerprint = RunGetOutput("ssh-keygen -lf /etc/ssh/ssh_host_" + type + "_key.pub")[1].rstrip().split()[1].replace(':','')
                    self.ReportRoleProperties(fingerprint)

if program != None and DiskActivated == True:
                try:
                    Children.append(subprocess.Popen([program, "Ready"]))
                except OSError, e :
                    ErrorWithPrefix('SharedConfig.Parse','Exception: '+ str(e) +' occured launching ' + program )
                program = None

sleepToReduceAccessDenied = 3
            time.sleep(sleepToReduceAccessDenied)
            if provisionError != None:
                incarnation = self.ReportNotReady("ProvisioningFailed", provisionError)
            else:
                incarnation = self.ReportReady()
            # Process our extensions.
            if goalState.ExtensionsConfig == None and goalState.ExtensionsConfigXml != None :
                reportHandlerStatusCount = 0 #Reset count when new goal state comes
                goalState.ExtensionsConfig = ExtensionsConfig().Parse(goalState.ExtensionsConfigXml)

# report the status/heartbeat results of extension processing
            if goalState.ExtensionsConfig != None :
                ret = goalState.ExtensionsConfig.ReportHandlerStatus()
                if ret != 0:
                    Error("Failed to report handler status")
                elif reportHandlerStatusCount % 1000 == 0:
                    #Agent report handler status every 25 seconds. Reduce the log entries by adding a count
                    Log("Successfully reported handler status")
                reportHandlerStatusCount += 1
            
            if not eventMonitor:
                eventMonitor = WALAEventMonitor(self.HttpPostWithHeaders)
                eventMonitor.StartEventsLoop()

time.sleep(25 - sleepToReduceAccessDenied)

WaagentLogrotate = """\
/var/log/waagent.log {
    monthly
    rotate 6
    notifempty
    missingok
}
"""

def GetMountPoint(mountlist, device):
    """
    Example of mountlist:
        /dev/sda1 on / type ext4 (rw)
        proc on /proc type proc (rw)
        sysfs on /sys type sysfs (rw)
        devpts on /dev/pts type devpts (rw,gid=5,mode=620)
        tmpfs on /dev/shm type tmpfs (rw,rootcontext="system_u:object_r:tmpfs_t:s0")
        none on /proc/sys/fs/binfmt_misc type binfmt_misc (rw)
        /dev/sdb1 on /mnt/resource type ext4 (rw)
    """
    if (mountlist and device):
        for entry in mountlist.split('\n'):
            if(re.search(device, entry)):
                tokens = entry.split()
                #Return the 3rd column of this line
                return tokens[2] if len(tokens) > 2 else None
    return None

def FindInLinuxKernelCmdline(option):
    """
    Return match object if 'option' is present in the kernel boot options
    of the grub configuration.
    """
    m=None
    matchs=r'^.*?'+MyDistro.grubKernelBootOptionsLine+r'.*?'+option+r'.*$'
    try:
        m=FindStringInFile(MyDistro.grubKernelBootOptionsFile,matchs)
    except IOError, e:
        Error('FindInLinuxKernelCmdline: Exception opening ' + MyDistro.grubKernelBootOptionsFile + 'Exception:' + str(e))
        
    return m

def AppendToLinuxKernelCmdline(option):
    """
    Add 'option' to the kernel boot options of the grub configuration.
    """
    if not FindInLinuxKernelCmdline(option):
        src=r'^(.*?'+MyDistro.grubKernelBootOptionsLine+r')(.*?)("?)$'
        rep=r'\1\2 '+ option + r'\3'
        try:
            ReplaceStringInFile(MyDistro.grubKernelBootOptionsFile,src,rep)
        except IOError, e :
            Error('AppendToLinuxKernelCmdline: Exception opening ' + MyDistro.grubKernelBootOptionsFile + 'Exception:' + str(e))
            return 1
        Run("update-grub",chk_err=False)    
    return 0

def RemoveFromLinuxKernelCmdline(option):
    """
    Remove 'option' to the kernel boot options of the grub configuration.
    """
    if FindInLinuxKernelCmdline(option):
        src=r'^(.*?'+MyDistro.grubKernelBootOptionsLine+r'.*?)('+option+r')(.*?)("?)$'
        rep=r'\1\3\4'
        try:
            ReplaceStringInFile(MyDistro.grubKernelBootOptionsFile,src,rep)
        except IOError, e :
            Error('RemoveFromLinuxKernelCmdline: Exception opening ' + MyDistro.grubKernelBootOptionsFile + 'Exception:' + str(e))
            return 1
        Run("update-grub",chk_err=False)    
    return 0

def FindStringInFile(fname,matchs):
    """
    Return match object if found in file.
    """
    try:
        ms=re.compile(matchs)
        for l in (open(fname,'r')).readlines():
            m=re.search(ms,l)
            if m:
                return m
    except:
        raise
    
    return None

def ReplaceStringInFile(fname,src,repl):
    """
    Replace 'src' with 'repl' in file.
    """
    try:
        sr=re.compile(src)
        if FindStringInFile(fname,src):
            updated=''
            for l in (open(fname,'r')).readlines():
                n=re.sub(sr,repl,l)
                updated+=n
            ReplaceFileContentsAtomic(fname,updated)
    except :
        raise
    return

def ApplyVNUMAWorkaround():
    """
    If kernel version has NUMA bug, add 'numa=off' to
    kernel boot options.
    """
    VersionParts = platform.release().replace('-', '.').split('.')
    if int(VersionParts[0]) > 2:
        return
    if int(VersionParts[1]) > 6:
        return
    if int(VersionParts[2]) > 37:
        return
    if AppendToLinuxKernelCmdline("numa=off") == 0 :
        Log("Your kernel version " + platform.release() + " has a NUMA-related bug: NUMA has been disabled.")
    else :
        "Error adding 'numa=off'.  NUMA has not been disabled."
        
def RevertVNUMAWorkaround():
    """
    Remove 'numa=off' from kernel boot options.
    """
    if RemoveFromLinuxKernelCmdline("numa=off") == 0 :
        Log('NUMA has been re-enabled')
    else :
        Log('NUMA has not been re-enabled')

def Install():
    """
    Install the agent service.
    Check dependencies.
    Create /etc/waagent.conf and move old version to
    /etc/waagent.conf.old
    Copy RulesFiles to /var/lib/waagent
    Create /etc/logrotate.d/waagent
    Set /etc/ssh/sshd_config ClientAliveInterval to 180
    Call ApplyVNUMAWorkaround()
    """
    if MyDistro.checkDependencies():
        return 1
    os.chmod(sys.argv[0], 0755)
    SwitchCwd()
    for a in RulesFiles:
        if os.path.isfile(a):
            if os.path.isfile(GetLastPathElement(a)):
                os.remove(GetLastPathElement(a))
            shutil.move(a, ".")
            Warn("Moved " + a + " -> " + LibDir + "/" + GetLastPathElement(a) )
    MyDistro.registerAgentService()
    if os.path.isfile("/etc/waagent.conf"):
        try:
            os.remove("/etc/waagent.conf.old")
        except:
            pass
        try:
            os.rename("/etc/waagent.conf", "/etc/waagent.conf.old")
            Warn("Existing /etc/waagent.conf has been renamed to /etc/waagent.conf.old")
        except:
            pass
    SetFileContents("/etc/waagent.conf", MyDistro.waagent_conf_file)
    SetFileContents("/etc/logrotate.d/waagent", WaagentLogrotate)
    filepath = "/etc/ssh/sshd_config"
    ReplaceFileContentsAtomic(filepath, "\n".join(filter(lambda a: not
        a.startswith("ClientAliveInterval"),
        GetFileContents(filepath).split('\n'))) + "\nClientAliveInterval 180\n")
    Log("Configured SSH client probing to keep connections alive.")
    ApplyVNUMAWorkaround()
    return 0

def GetMyDistro(dist_class_name=''):
    """
    Return MyDistro object.
    NOTE: Logging is not initialized at this point.
    """
    if dist_class_name == '':
        if 'Linux' in platform.system():
            Distro=DistInfo()[0]
        else : # I know this is not Linux!
            if 'FreeBSD' in platform.system():
                Distro=platform.system()
        Distro=Distro.strip('"')
        Distro=Distro.strip(' ')
        dist_class_name=Distro+'Distro'
    else:
        Distro=dist_class_name
    if not globals().has_key(dist_class_name):
        print Distro+' is not a supported distribution.'
        return None
    return globals()[dist_class_name]() # the distro class inside this module.

def DistInfo(fullname=0):
    if 'FreeBSD' in platform.system():
        release = re.sub('\-.*\Z', '', str(platform.release()))
        distinfo = ['FreeBSD', release]
        return distinfo
    
    if 'linux_distribution' in dir(platform):
        distinfo = list(platform.linux_distribution(full_distribution_name=fullname))
        distinfo[0] = distinfo[0].strip() # remove trailing whitespace in distro name
        if os.path.exists("/etc/euleros-release"):
            distinfo[0] = "euleros"
        return distinfo
    else:
        return platform.dist()

def PackagedInstall(buildroot):
    """
    Called from setup.py for use by RPM.
    Generic implementation Creates directories and
    files /etc/waagent.conf, /etc/init.d/waagent, /usr/sbin/waagent,
    /etc/logrotate.d/waagent, /etc/sudoers.d/waagent under buildroot.
    Copies generated files waagent.conf, into place and exits.
    """
    MyDistro=GetMyDistro()
    if MyDistro == None :
        sys.exit(1)
    MyDistro.packagedInstall(buildroot)

def LibraryInstall(buildroot):
    pass

def Uninstall():
    """
    Uninstall the agent service.
    Copy RulesFiles back to original locations.
    Delete agent-related files.
    Call RevertVNUMAWorkaround().
    """
    SwitchCwd()
    for a in RulesFiles:
        if os.path.isfile(GetLastPathElement(a)):
            try:
                shutil.move(GetLastPathElement(a), a)
                Warn("Moved " + LibDir + "/" + GetLastPathElement(a) + " -> " + a )
            except:
                pass
    MyDistro.unregisterAgentService()
    MyDistro.uninstallDeleteFiles()
    RevertVNUMAWorkaround()
    return 0

def Deprovision(force, deluser):
    """
    Remove user accounts created by provisioning.
    Disables root password if Provisioning.DeleteRootPassword = 'y'
    Stop agent service.
    Remove SSH host keys if they were generated by the provision.
    Set hostname to 'localhost.localdomain'.
    Delete cached system configuration files in /var/lib and /var/lib/waagent.
    """
    
    #Append blank line at the end of file, so the ctime of this file is changed every time
    Run("echo ''>>"+ MyDistro.getConfigurationPath())

SwitchCwd()
    ovfxml = GetFileContents(LibDir+"/ovf-env.xml")
    ovfobj = None
    if ovfxml != None:
        ovfobj = OvfEnv().Parse(ovfxml, True)

print("WARNING! The waagent service will be stopped.")
    print("WARNING! All SSH host key pairs will be deleted.")
    print("WARNING! Cached DHCP leases will be deleted.")
    MyDistro.deprovisionWarnUser()
    delRootPass = Config.get("Provisioning.DeleteRootPassword")
    if delRootPass != None and delRootPass.lower().startswith("y"):
        print("WARNING! root password will be disabled. You will not be able to login as root.")

if ovfobj != None and deluser == True:
        print("WARNING! " + ovfobj.UserName + " account and entire home directory will be deleted.")

if force == False and not raw_input('Do you want to proceed (y/n)? ').startswith('y'):
        return 1

MyDistro.stopAgentService()

# Remove SSH host keys
    regenerateKeys = Config.get("Provisioning.RegenerateSshHostKeyPair")
    if regenerateKeys == None or regenerateKeys.lower().startswith("y"):
        Run("rm -f /etc/ssh/ssh_host_*key*")

# Remove root password
    if delRootPass != None and delRootPass.lower().startswith("y"):
        MyDistro.deleteRootPassword()
    # Remove distribution specific networking configuration

MyDistro.publishHostname('localhost.localdomain')
    MyDistro.deprovisionDeleteFiles()
    if deluser == True:
        MyDistro.DeleteAccount(ovfobj.UserName)
    return 0

def SwitchCwd():
    """
    Switch to cwd to /var/lib/waagent.
    Create if not present.
    """
    CreateDir(LibDir, "root", 0700)
    os.chdir(LibDir)

def main():
    """
    Instantiate MyDistro, exit if distro class is not defined.
    Parse command-line arguments, exit with usage() on error.
    Instantiate ConfigurationProvider.
    Call appropriate non-daemon methods and exit.
    If daemon mode, enter Agent.Run() loop.
    """
    if GuestAgentVersion == "":
        print("WARNING! This is a non-standard agent that does not include a valid version string.")
    
    if len(sys.argv) == 1:
        sys.exit(Usage())

LoggerInit('/var/log/waagent.log','/dev/console')
    global LinuxDistro
    LinuxDistro=DistInfo()[0]
    
    global MyDistro
    MyDistro=GetMyDistro()
    if MyDistro == None :
        sys.exit(1)
    args = []
    conf_file = None
    global force
    force = False
    for a in sys.argv[1:]:
        if re.match("^([-/]*)(help|usage|\?)", a):
            sys.exit(Usage())
        elif re.match("^([-/]*)version", a):
            print(GuestAgentVersion + " running on " + LinuxDistro)
            sys.exit(0)
        elif re.match("^([-/]*)verbose", a):
            myLogger.verbose = True
        elif re.match("^([-/]*)force", a):
            force = True
        elif re.match("^(?:[-/]*)conf=.+", a):
            conf_file = re.match("^(?:[-/]*)conf=(.+)", a).groups()[0]
        elif re.match("^([-/]*)(setup|install)", a):
            sys.exit(MyDistro.Install())
        elif re.match("^([-/]*)(uninstall)", a):
            sys.exit(Uninstall())
        else:
            args.append(a)
    global Config
    Config = ConfigurationProvider(conf_file)
    
    logfile = Config.get("Logs.File")
    if logfile is not None:
        myLogger.file_path = logfile
    logconsole = Config.get("Logs.Console")
    if logconsole is not None and logconsole.lower().startswith("n"):
        myLogger.con_path = None
    verbose = Config.get("Logs.Verbose")
    if verbose != None and verbose.lower().startswith("y"):
        myLogger.verbose=True
    global daemon
    daemon = False
    for a in args:
        if re.match("^([-/]*)deprovision\+user", a):
            sys.exit(Deprovision(force, True))
        elif re.match("^([-/]*)deprovision", a):
            sys.exit(Deprovision(force, False))
        elif re.match("^([-/]*)daemon", a):
            daemon = True
        elif re.match("^([-/]*)serialconsole", a):
            AppendToLinuxKernelCmdline("console=ttyS0 earlyprintk=ttyS0")
            Log("Configured kernel to use ttyS0 as the boot console.")
            sys.exit(0)
        else:
            print("Invalid command line parameter:" + a)
            sys.exit(1)
    
    if daemon == False:
        sys.exit(Usage())
    global modloaded
    modloaded = False
   
    while True:
        try:
            SwitchCwd()
            Log(GuestAgentLongName + " Version: " + GuestAgentVersion)
            if IsLinux():
                Log("Linux Distribution Detected      : " + LinuxDistro)
            global WaAgent
            WaAgent = Agent()
            WaAgent.Run()
        except Exception, e:
            Error(traceback.format_exc())
            Error("Exception: " + str(e))
            Log("Restart agent in 15 seconds")
            time.sleep(15)
    
if __name__ == '__main__' :
    main()

${this.title}

Code Editor : waagent2.0