#!/usr/bin/env python
#
# Internet Systems Consortium license
#
# Copyright (c) 2014, Franck Cuny (<franckcuny@gmail.com>)
#
# Permission to use, copy, modify, and/or distribute this software for any purpose
# with or without fee is hereby granted, provided that the above copyright notice
# and this permission notice appear in all copies.
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
# FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
# INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
# OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
# TORTUOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
# THIS SOFTWARE.
# TODO -- proper exception handling and meaningful error codes
'''
Foreman external inventory script
=================================
Generates inventory that Ansible can understand by making API requests
to Foreman.
Information about the Foreman's instance can be stored in the ``foreman.ini`` file.
A ``base_url``, ``username`` and ``password`` need to be provided. The path to an
alternate configuration file can be provided by exporting the ``FOREMAN_INI_PATH``
variable.
When run against a specific host, this script returns the following variables
based on the data obtained from Foreman:
- id
- ip
- name
- environment
- os
- model
- compute_resource
- domain
- architecture
- created
- updated
- status
- hostgroup
- ansible_ssh_host
When run in --list mode, instances are grouped by the following categories:
- group
Examples:
Execute uname on all instances in the dev group
$ ansible -i theforeman.py dev -m shell -a \"/bin/uname -a\"
Authors: Franck Cuny <franckcuny@gmail.com>
Andrew Deck <andrew.deck@outlook.com>
Version: 0.0.2
'''
import sys
import os
import re
import optparse
import ConfigParser
import collections
try:
import json
except ImportError:
import simplejson as json
try:
from foreman.client import Foreman
from requests.exceptions import ConnectionError
except ImportError, e:
print ('python-foreman required for this module')
print e
sys.exit(1)
class CLIMain(object):
def __init__(self):
"""Program entry point"""
settings = self.read_settings()
self.parse_cli_args()
foreman = ForemanInventory(settings['username']
,settings['password']
,settings['base_url'])
if self.args.all:
data_to_print = foreman.get_all()
elif self.args.host:
data_to_print = foreman.get_host_info(self.args.host)
elif self.args.list:
data_to_print = foreman.get_inventory()
else:
data_to_print = {}
print(json.dumps(data_to_print, sort_keys=True, indent=4))
def read_settings(self):
"""Read the settings from the foreman.ini file"""
config = ConfigParser.SafeConfigParser()
scriptdir = os.path.dirname(os.path.realpath(__file__))
foreman_default_ini_path = os.path.join(scriptdir, 'foreman.ini')
foreman_ini_path = os.environ.get('FOREMAN_INI_PATH', foreman_default_ini_path)
config.read(foreman_ini_path)
settings = {}
required = ['base_url', 'username', 'password']
missing = []
for setting in required:
val = config.get('foreman', setting)
if val is None:
missing.append(setting)
settings[setting] = val
if missing != []:
raise Exception("Could not find values for Foreman " + ', '.join(missing)
+ ". They must be specified via ini file.")
return settings
def parse_cli_args(self):
"""Command line argument processing"""
description = 'Produce an Ansible Inventory file based on Foreman'
parser = optparse.OptionParser(description=description)
parser.add_option('--list', action='store_true', default=True,
help='List instances (default: True)')
parser.add_option('--host', action='store',
help='Get all the variables about a specific instance')
parser.add_option('--all', action='store_true',
help= 'Get all the variables for all the instances')
(self.args, self.options) = parser.parse_args()
class ForemanInventory(object):
"""Foreman Inventory"""
def _empty_inventory(self):
"""Empty inventory"""
return {'_meta': {'hostvars': {}}}
def _empty_cache(self):
"""Empty cache"""
keys = ['operatingsystem', 'hostgroup', 'environment', 'model',
'compute_resource', 'domain', 'subnet', 'architecture',
'host']
keys_d = {}
for i in keys:
keys_d[i] = {}
return keys_d
def __init__(self, username, password, foreman_url):
# initializing vars
self.base_url = foreman_url
self.username = username
self.password = password
self.inventory = self._empty_inventory()
self._cache = self._empty_cache()
try:
self.client = Foreman(self.base_url, (self.username, self.password))
except ConnectionError, e:
raise Exception("It looks like Foreman's API is unreachable. Error "
"was: " + str(e))
def get_host_info(self, host_id):
"""Get information about an host"""
host_desc = {}
meta = self._get_object_from_id('host', host_id)
if meta is None:
return host_desc
for k in ['id', 'ip', 'name', 'status']:
host_desc[k] = meta.get(k)
for k in ['model', 'compute_resource', 'domain', 'subnet'
,'architecture', 'hostgroup']:
host_desc[k] = self._get_from_type(k, meta)
for k in ['created', 'updated']:
host_desc[k] = meta.get(k + '_at')
host_desc['os'] = self._get_from_type('operatingsystem', meta)
try:
k = 'environment'
host_desc[k] = meta.get(k).get(k).get('name').lower()
except Exception:
pass # do nothing
# to ssh from ansible
host_desc['ansible_ssh_host'] = host_desc['ip']
return host_desc
def get_inventory(self):
"""Get all the hosts from the inventory"""
groups = collections.defaultdict(list)
hosts = []
page = 1
while True:
resp = self.client.index_hosts(page=page)
if len(resp) < 1:
break
page += 1
hosts += resp
if len(hosts) < 1:
return groups
for host in hosts:
host_group = self._get_from_id('hostgroup', host.get('host').get('hostgroup_id'))
server_name = host.get('host').get('name')
groups[host_group].append(server_name)
return groups
def get_all(self):
"""Get all the machines and all the variables for all the machines"""
groups = self.get_inventory()
hosts = {}
for group in groups:
for host in groups[group]:
hosts[host] = True
for host in hosts:
hosts[host] = self.get_host_info(host)
groups['_meta'] = {'hostvars': hosts}
return groups
def _get_from_type(self, param_type, host):
return self._get_from_id(param_type, host.get(param_type + '_id'))
def _get_from_id(self, param_type, param_id):
"""Get the object of type param_type associated with the ID param_id
The following values for param_type are explicitly accounted for:
- architecture
- subnet
- domain
- compute_resource
- model
- environment
- label
- hostgroup
- operatingsystem
"""
param = self._get_object_from_id(param_type, param_id)
if param is None:
return None
if param_type == "hostgroup":
return param.get('label')
elif param_type == 'operatingsystem':
return "{0}-{1}".format(param.get('name'), param.get('major'))
elif param_type == 'environment':
return param.get('name').lower()
else:
return param.get('name')
def _get_object_from_id(self, obj_type, obj_id):
"""Get an object from it's ID"""
if obj_id is None:
return None
obj = self._cache.get(obj_type).get(obj_id, None)
if obj is None:
method_name = "show_{0}s".format(obj_type)
func = getattr(self.client, method_name)
obj = func(obj_id)
self._cache[obj_type][obj_id] = obj
return obj.get(obj_type)
if __name__ == '__main__':
CLIMain()
