834f6a216d
Tested with OS X local connection and Linux remote. The paths to the md5sum and md5 commands are hardcoded to the most common location. This will definitely fail if the commands are elsewhere, or if the md5 command doesn't support the -q 'quiet' option.
409 lines
14 KiB
Python
Executable file
409 lines
14 KiB
Python
Executable file
#!/usr/bin/python
|
|
|
|
# (c) 2012, Michael DeHaan <michael.dehaan@gmail.com>
|
|
#
|
|
# This file is part of Ansible
|
|
#
|
|
# Ansible is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# Ansible is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
DEFAULT_ANSIBLE_SETUP = "/etc/ansible/setup"
|
|
|
|
import array
|
|
import fcntl
|
|
import glob
|
|
import sys
|
|
import os
|
|
import platform
|
|
import re
|
|
import shlex
|
|
import socket
|
|
import struct
|
|
import subprocess
|
|
import traceback
|
|
import syslog
|
|
|
|
try:
|
|
import selinux
|
|
HAVE_SELINUX=True
|
|
except ImportError:
|
|
HAVE_SELINUX=False
|
|
|
|
try:
|
|
import json
|
|
except ImportError:
|
|
import simplejson as json
|
|
|
|
_I386RE = re.compile(r'i[3456]86')
|
|
SIOCGIFCONF = 0x8912
|
|
SIOCGIFHWADDR = 0x8927
|
|
MEMORY_FACTS = ['MemTotal', 'SwapTotal', 'MemFree', 'SwapFree']
|
|
# DMI bits
|
|
DMI_DICT = { 'form_factor': '/sys/devices/virtual/dmi/id/chassis_type',
|
|
'product_name': '/sys/devices/virtual/dmi/id/product_name',
|
|
'product_serial': '/sys/devices/virtual/dmi/id/product_serial',
|
|
'product_uuid': '/sys/devices/virtual/dmi/id/product_uuid',
|
|
'product_version': '/sys/devices/virtual/dmi/id/product_version',
|
|
'system_vendor': '/sys/devices/virtual/dmi/id/sys_vendor',
|
|
'bios_date': '/sys/devices/virtual/dmi/id/bios_date',
|
|
'bios_version': '/sys/devices/virtual/dmi/id/bios_version' }
|
|
# From smolt and DMI spec
|
|
FORM_FACTOR = [ "Unknown", "Other", "Unknown", "Desktop",
|
|
"Low Profile Desktop", "Pizza Box", "Mini Tower", "Tower",
|
|
"Portable", "Laptop", "Notebook", "Hand Held", "Docking Station",
|
|
"All In One", "Sub Notebook", "Space-saving", "Lunch Box",
|
|
"Main Server Chassis", "Expansion Chassis", "Sub Chassis",
|
|
"Bus Expansion Chassis", "Peripheral Chassis", "RAID Chassis",
|
|
"Rack Mount Chassis", "Sealed-case PC", "Multi-system",
|
|
"CompactPCI", "AdvancedTCA" ]
|
|
# For the most part, we assume that platform.dist() will tell the truth.
|
|
# This is the fallback to handle unknowns or exceptions
|
|
OSDIST_DICT = { '/etc/redhat-release': 'RedHat',
|
|
'/etc/vmware-release': 'VMwareESX' }
|
|
SELINUX_MODE_DICT = { 1: 'enforcing', 0: 'permissive', -1: 'disabled' }
|
|
|
|
def get_file_content(path):
|
|
if os.path.exists(path) and os.access(path, os.R_OK):
|
|
data = open(path).read().strip()
|
|
if len(data) == 0:
|
|
data = None
|
|
else:
|
|
data = None
|
|
return data
|
|
|
|
# platform.dist() is deprecated in 2.6
|
|
# in 2.6 and newer, you should use platform.linux_distribution()
|
|
def get_distribution_facts(facts):
|
|
dist = platform.dist()
|
|
facts['distribution'] = dist[0].capitalize() or 'NA'
|
|
facts['distribution_version'] = dist[1] or 'NA'
|
|
facts['distribution_release'] = dist[2] or 'NA'
|
|
# Try to handle the exceptions now ...
|
|
for (path, name) in OSDIST_DICT.items():
|
|
if os.path.exists(path):
|
|
if facts['distribution'] == 'Fedora':
|
|
pass
|
|
elif name == 'RedHat':
|
|
data = get_file_content(path)
|
|
if 'Red Hat' in data:
|
|
facts['distribution'] = name
|
|
else:
|
|
facts['distribution'] = data.split()[0]
|
|
else:
|
|
facts['distribution'] = name
|
|
|
|
# Platform
|
|
# patform.system() can be Linux, Darwin, Java, or Windows
|
|
def get_platform_facts(facts):
|
|
facts['system'] = platform.system()
|
|
facts['kernel'] = platform.release()
|
|
facts['machine'] = platform.machine()
|
|
facts['python_version'] = platform.python_version()
|
|
if facts['machine'] == 'x86_64':
|
|
facts['architecture'] = facts['machine']
|
|
elif _I386RE.search(facts['machine']):
|
|
facts['architecture'] = 'i386'
|
|
else:
|
|
facts['archtecture'] = facts['machine']
|
|
if facts['system'] == 'Linux':
|
|
get_distribution_facts(facts)
|
|
|
|
def get_memory_facts(facts):
|
|
if not os.access("/proc/meminfo", os.R_OK):
|
|
return facts
|
|
for line in open("/proc/meminfo").readlines():
|
|
data = line.split(":", 1)
|
|
key = data[0]
|
|
if key in MEMORY_FACTS:
|
|
val = data[1].strip().split(' ')[0]
|
|
facts["%s_mb" % key.lower()] = long(val) / 1024
|
|
|
|
def get_cpu_facts(facts):
|
|
i = 0
|
|
physid = 0
|
|
sockets = {}
|
|
if not os.access("/proc/cpuinfo", os.R_OK):
|
|
return facts
|
|
for line in open("/proc/cpuinfo").readlines():
|
|
data = line.split(":", 1)
|
|
key = data[0].strip()
|
|
if key == 'model name':
|
|
if 'processor' not in facts:
|
|
facts['processor'] = []
|
|
facts['processor'].append(data[1].strip())
|
|
i += 1
|
|
elif key == 'physical id':
|
|
physid = data[1].strip()
|
|
if physid not in sockets:
|
|
sockets[physid] = 1
|
|
elif key == 'cpu cores':
|
|
sockets[physid] = int(data[1].strip())
|
|
if len(sockets) > 0:
|
|
facts['processor_count'] = len(sockets)
|
|
facts['processor_cores'] = reduce(lambda x, y: x + y, sockets.values())
|
|
else:
|
|
facts['processor_count'] = i
|
|
facts['processor_cores'] = 'NA'
|
|
|
|
def get_hardware_facts(facts):
|
|
get_memory_facts(facts)
|
|
get_cpu_facts(facts)
|
|
for (key,path) in DMI_DICT.items():
|
|
data = get_file_content(path)
|
|
if data is not None:
|
|
if key == 'form_factor':
|
|
facts['form_factor'] = FORM_FACTOR[int(data)]
|
|
else:
|
|
facts[key] = data
|
|
else:
|
|
facts[key] = 'NA'
|
|
|
|
def get_linux_virtual_facts(facts):
|
|
if os.path.exists("/proc/xen"):
|
|
facts['virtualization_type'] = 'xen'
|
|
facts['virtualization_role'] = 'guest'
|
|
if os.path.exists("/proc/xen/capabilities"):
|
|
facts['virtualization_role'] = 'host'
|
|
if os.path.exists("/proc/modules"):
|
|
modules = []
|
|
for line in open("/proc/modules").readlines():
|
|
data = line.split(" ", 1)
|
|
modules.append(data[0])
|
|
if 'kvm' in modules:
|
|
facts['virtualization_type'] = 'kvm'
|
|
facts['virtualization_role'] = 'host'
|
|
elif 'vboxdrv' in modules:
|
|
facts['virtualization_type'] = 'virtualbox'
|
|
facts['virtualization_role'] = 'host'
|
|
elif 'vboxguest' in modules:
|
|
facts['virtualization_type'] = 'virtualbox'
|
|
facts['virtualization_role'] = 'guest'
|
|
if 'QEMU' in facts['processor'][0]:
|
|
facts['virtualization_type'] = 'kvm'
|
|
facts['virtualization_role'] = 'guest'
|
|
if facts['distribution'] == 'VMwareESX':
|
|
facts['virtualization_type'] = 'VMware'
|
|
facts['virtualization_role'] = 'host'
|
|
# You can spawn a dmidecode process and parse that or infer from devices
|
|
for dev_model in glob.glob('/sys/block/?da/device/vendor'):
|
|
info = open(dev_model).read()
|
|
if 'VMware' in info:
|
|
facts['virtualization_type'] = 'VMware'
|
|
facts['virtualization_role'] = 'guest'
|
|
elif 'Virtual HD' in info or 'Virtual CD' in info:
|
|
facts['virtualization_type'] = 'VirtualPC'
|
|
facts['virtualization_role'] = 'guest'
|
|
|
|
def get_virtual_facts(facts):
|
|
facts['virtualization_type'] = 'None'
|
|
facts['virtualization_role'] = 'None'
|
|
if facts['system'] == 'Linux':
|
|
facts = get_linux_virtual_facts(facts)
|
|
|
|
# get list of interfaces that are up
|
|
def get_interfaces():
|
|
length = 4096
|
|
offset = 32
|
|
step = 32
|
|
if platform.architecture()[0] == '64bit':
|
|
offset = 16
|
|
step = 40
|
|
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
|
names = array.array('B', '\0' * length)
|
|
bytelen = struct.unpack('iL', fcntl.ioctl(
|
|
s.fileno(), SIOCGIFCONF, struct.pack(
|
|
'iL', length, names.buffer_info()[0])
|
|
))[0]
|
|
return [names.tostring()[i:i+offset].split('\0', 1)[0]
|
|
for i in range(0, bytelen, step)]
|
|
|
|
def get_iface_hwaddr(iface):
|
|
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
|
info = fcntl.ioctl(s.fileno(), SIOCGIFHWADDR,
|
|
struct.pack('256s', iface[:15]))
|
|
return ''.join(['%02x:' % ord(char) for char in info[18:24]])[:-1]
|
|
|
|
def get_network_facts(facts):
|
|
facts['fqdn'] = socket.getfqdn()
|
|
facts['hostname'] = facts['fqdn'].split('.')[0]
|
|
facts['interfaces'] = get_interfaces()
|
|
for iface in facts['interfaces']:
|
|
facts[iface] = { 'macaddress': get_iface_hwaddr(iface) }
|
|
# This is lame, but there doesn't appear to be a good way
|
|
# to get all addresses for both IPv4 and IPv6.
|
|
cmd = subprocess.Popen("/sbin/ifconfig %s" % iface, shell=True,
|
|
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
out, err = cmd.communicate()
|
|
for line in out.split('\n'):
|
|
data = line.split()
|
|
if 'inet addr' in line:
|
|
if 'ipv4' not in facts[iface]:
|
|
facts[iface]['ipv4'] = {}
|
|
facts[iface]['ipv4'] = { 'address': data[1].split(':')[1],
|
|
'netmask': data[-1].split(':')[1] }
|
|
ip = struct.unpack("!L", socket.inet_aton(facts[iface]['ipv4']['address']))[0]
|
|
mask = struct.unpack("!L", socket.inet_aton(facts[iface]['ipv4']['netmask']))[0]
|
|
facts[iface]['ipv4']['network'] = socket.inet_ntoa(struct.pack("!L", ip & mask))
|
|
if 'inet6 addr' in line:
|
|
(ip, prefix) = data[2].split('/')
|
|
scope = data[3].split(':')[1].lower()
|
|
if 'ipv6' not in facts[iface]:
|
|
facts[iface]['ipv6'] = []
|
|
facts[iface]['ipv6'].append( { 'address': ip,
|
|
'prefix': prefix,
|
|
'scope': scope } )
|
|
return facts
|
|
|
|
def get_public_ssh_host_keys(facts):
|
|
dsa = get_file_content('/etc/ssh/ssh_host_dsa_key.pub')
|
|
rsa = get_file_content('/etc/ssh/ssh_host_rsa_key.pub')
|
|
if dsa is None:
|
|
dsa = 'NA'
|
|
else:
|
|
facts['ssh_host_key_dsa_public'] = dsa.split()[1]
|
|
if rsa is None:
|
|
rsa = 'NA'
|
|
else:
|
|
facts['ssh_host_key_rsa_public'] = rsa.split()[1]
|
|
|
|
def get_selinux_facts(facts):
|
|
if not HAVE_SELINUX:
|
|
facts['selinux'] = False
|
|
return
|
|
facts['selinux'] = {}
|
|
if not selinux.is_selinux_enabled():
|
|
facts['selinux']['status'] = 'disabled'
|
|
else:
|
|
facts['selinux']['status'] = 'enabled'
|
|
facts['selinux']['policyvers'] = selinux.security_policyvers()
|
|
(rc, configmode) = selinux.selinux_getenforcemode()
|
|
if rc == 0 and SELINUX_MODE_DICT.has_key(configmode):
|
|
facts['selinux']['config_mode'] = SELINUX_MODE_DICT[configmode]
|
|
mode = selinux.security_getenforce()
|
|
if SELINUX_MODE_DICT.has_key(mode):
|
|
facts['selinux']['mode'] = SELINUX_MODE_DICT[mode]
|
|
(rc, policytype) = selinux.selinux_getpolicytype()
|
|
if rc == 0:
|
|
facts['selinux']['type'] = policytype
|
|
|
|
def get_service_facts(facts):
|
|
get_public_ssh_host_keys(facts)
|
|
get_selinux_facts(facts)
|
|
|
|
def ansible_facts():
|
|
facts = {}
|
|
get_platform_facts(facts)
|
|
get_hardware_facts(facts)
|
|
get_virtual_facts(facts)
|
|
get_network_facts(facts)
|
|
get_service_facts(facts)
|
|
return facts
|
|
|
|
# load config & template variables
|
|
|
|
if len(sys.argv) == 1:
|
|
sys.exit(1)
|
|
|
|
|
|
argfile = sys.argv[1]
|
|
if not os.path.exists(argfile):
|
|
sys.exit(1)
|
|
|
|
setup_options = open(argfile).read().strip()
|
|
try:
|
|
setup_options = json.loads(setup_options)
|
|
except:
|
|
list_options = shlex.split(setup_options)
|
|
setup_options = {}
|
|
for opt in list_options:
|
|
(k,v) = opt.split("=")
|
|
setup_options[k]=v
|
|
|
|
syslog.openlog('ansible-%s' % os.path.basename(__file__))
|
|
syslog.syslog(syslog.LOG_NOTICE, 'Invoked with %s' % setup_options)
|
|
|
|
ansible_file = os.path.expandvars(setup_options.get('metadata', DEFAULT_ANSIBLE_SETUP))
|
|
ansible_dir = os.path.dirname(ansible_file)
|
|
|
|
# create the config dir if it doesn't exist
|
|
|
|
if not os.path.exists(ansible_dir):
|
|
os.makedirs(ansible_dir)
|
|
|
|
changed = False
|
|
md5sum = None
|
|
if not os.path.exists(ansible_file):
|
|
changed = True
|
|
else:
|
|
md5sum = os.popen("/usr/bin/md5sum %(file)s 2> /dev/null || /sbin/md5 -q %(file)s" % {"file": ansible_file}).read().split()[0]
|
|
|
|
# Get some basic facts in case facter or ohai are not installed
|
|
for (k, v) in ansible_facts().items():
|
|
setup_options["ansible_%s" % k] = v
|
|
|
|
# if facter is installed, and we can use --json because
|
|
# ruby-json is ALSO installed, include facter data in the JSON
|
|
|
|
if os.path.exists("/usr/bin/facter"):
|
|
cmd = subprocess.Popen("/usr/bin/facter --json", shell=True,
|
|
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
out, err = cmd.communicate()
|
|
facter = True
|
|
try:
|
|
facter_ds = json.loads(out)
|
|
except:
|
|
facter = False
|
|
if facter:
|
|
for (k,v) in facter_ds.items():
|
|
setup_options["facter_%s" % k] = v
|
|
|
|
# ditto for ohai, but just top level string keys
|
|
# because it contains a lot of nested stuff we can't use for
|
|
# templating w/o making a nicer key for it (TODO)
|
|
|
|
if os.path.exists("/usr/bin/ohai"):
|
|
cmd = subprocess.Popen("/usr/bin/ohai", shell=True,
|
|
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
out, err = cmd.communicate()
|
|
ohai = True
|
|
try:
|
|
ohai_ds = json.loads(out)
|
|
except:
|
|
ohai = False
|
|
if ohai:
|
|
for (k,v) in ohai_ds.items():
|
|
if type(v) == str or type(v) == unicode:
|
|
k2 = "ohai_%s" % k
|
|
setup_options[k2] = v
|
|
|
|
# write the template/settings file using
|
|
# instructions from server
|
|
|
|
f = open(ansible_file, "w+")
|
|
reformat = json.dumps(setup_options, sort_keys=True, indent=4)
|
|
f.write(reformat)
|
|
f.close()
|
|
|
|
md5sum2 = os.popen("/usr/bin/md5sum %(file)s 2> /dev/null || /sbin/md5 -q %(file)s" % {"file": ansible_file}).read().split()[0]
|
|
|
|
if md5sum != md5sum2:
|
|
changed = True
|
|
|
|
setup_result = {}
|
|
setup_result['written'] = ansible_file
|
|
setup_result['changed'] = changed
|
|
setup_result['md5sum'] = md5sum2
|
|
setup_result['ansible_facts'] = setup_options
|
|
|
|
print json.dumps(setup_result)
|
|
|