def __init__(self, api_key=None, url=maas_url):
if api_key == None:
self.api_key = self.get_api_key()
else:
self.api_key = api_key
self.auth = MAASOAuth(*self.api_key.split(':'))
self.url = url
self.client = MAASClient(self.auth, MAASDispatcher(), self.url)
def create_node(mac, arch, power_type, power_parameters):
api_credentials = get_recorded_api_credentials()
if api_credentials is None:
raise Exception('Not creating node: no API key yet.')
client = MAASClient(MAASOAuth(*api_credentials), MAASDispatcher(),
get_maas_url())
data = {
'op': 'new',
'architecture': arch,
'power_type': power_type,
'power_parameters': power_parameters,
'mac_addresses': mac
}
return client.post('/api/1.0/nodes/', data)
def make_client(root=None, result=None):
"""Create a MAASClient."""
if root is None:
root = make_url()
auth = MAASOAuth(factory.getRandomString(), factory.getRandomString(),
factory.getRandomString())
return MAASClient(auth, FakeDispatcher(result=result), root)
def evaluate_tag(
system_id,
nodes,
tag_name,
tag_definition,
tag_nsmap,
credentials,
maas_url,
):
"""Evaluate `tag_definition` against this cluster's nodes' details.
:param system_id: System ID for the rack controller.
:param nodes: List of nodes to evaluate.
:param tag_name: The name of the tag, used for logging.
:param tag_definition: The XPath expression of the tag.
:param tag_nsmap: The namespace map as used by LXML's ETree library.
:param credentials: A 3-tuple of OAuth credentials.
:param maas_url: URL of the MAAS API.
"""
# Turn off proxy detection, since the rack should talk directly to
# the region, even if a system-wide proxy is configured.
client = MAASClient(
auth=MAASOAuth(*credentials),
dispatcher=MAASDispatcher(autodetect_proxies=False),
base_url=maas_url,
)
process_node_tags(
rack_id=system_id,
nodes=nodes,
tag_name=tag_name,
tag_definition=tag_definition,
tag_nsmap=tag_nsmap,
client=client,
)
def create_node(mac, arch, power_type, power_parameters):
api_credentials = get_recorded_api_credentials()
if api_credentials is None:
raise Exception('Not creating node: no API key yet.')
client = MAASClient(
MAASOAuth(*api_credentials), MAASDispatcher(),
get_maas_url())
data = {
'op': 'new',
'architecture': arch,
'power_type': power_type,
'power_parameters': power_parameters,
'mac_addresses': mac
}
return client.post('/api/1.0/nodes/', data)
def evaluate_tag(
system_id,
nodes,
tag_name,
tag_definition,
tag_nsmap,
credentials,
maas_url,
):
"""Evaluate `tag_definition` against this cluster's nodes' details.
:param system_id: System ID for the rack controller.
:param nodes: List of nodes to evaluate.
:param tag_name: The name of the tag, used for logging.
:param tag_definition: The XPath expression of the tag.
:param tag_nsmap: The namespace map as used by LXML's ETree library.
:param credentials: A 3-tuple of OAuth credentials.
:param maas_url: URL of the MAAS API.
"""
client = MAASClient(
auth=MAASOAuth(*credentials),
dispatcher=MAASDispatcher(),
base_url=maas_url,
)
process_node_tags(
rack_id=system_id,
nodes=nodes,
tag_name=tag_name,
tag_definition=tag_definition,
tag_nsmap=tag_nsmap,
client=client,
)
def submit(maas_url, api_credentials, images):
"""Submit images to server."""
MAASClient(MAASOAuth(*api_credentials), MAASDispatcher(),
maas_url).post('api/1.0/boot-images/',
'report_boot_images',
nodegroup=get_cluster_uuid(),
images=json.dumps(images))
def make_client(root=None, result=None):
"""Create a MAASClient."""
if root is None:
root = factory.make_simple_http_url(path=factory.make_name("path") +
"/")
auth = MAASOAuth(factory.make_string(), factory.make_string(),
factory.make_string())
return MAASClient(auth, FakeDispatcher(result=result), root)
def update_region_controller(knowledge, interface, server):
"""Update the region controller with the status of the probe.
:param knowledge: dictionary of server info
:param interface: name of interface, e.g. eth0
:param server: IP address of detected DHCP server, or None
"""
api_path = 'api/1.0/nodegroups/%s/interfaces/%s/' % (
knowledge['nodegroup_uuid'], interface)
oauth = MAASOAuth(*knowledge['api_credentials'])
client = MAASClient(oauth, MAASDispatcher(), knowledge['maas_url'])
if server is None:
server = ''
process_request(client.put, api_path, foreign_dhcp_ip=server)
def get_cached_knowledge():
"""Get all the information that we need to know, or raise an error.
:return: (client, nodegroup_uuid)
"""
api_credentials = get_recorded_api_credentials()
if api_credentials is None:
logger.error("Not updating tags: don't have API key yet.")
return None, None
nodegroup_uuid = get_recorded_nodegroup_uuid()
if nodegroup_uuid is None:
logger.error("Not updating tags: don't have UUID yet.")
return None, None
client = MAASClient(MAASOAuth(*api_credentials), MAASDispatcher(),
get_maas_url())
return client, nodegroup_uuid
def _getclient(url=u'http://localhost/MAAS/api/1.0/'):
'''
Use the MAAS apiclient to aquire a session with the Maas API
:param url:
How to connect to the Maas server. As we require the Maas tools
installed on the executing machine, this can be the localhost by default.
:return:
A MAASClient object
'''
global _mclient
if _mclient is None:
consumer_key, token, secret = key('root').split(':', 3)
auth = MAASOAuth(consumer_key, token, secret)
dispatch = MAASDispatcher()
_mclient = MAASClient(auth, dispatch, url)
return _mclient
class MaasTagging(object):
def __init__(self):
""" Main execution path """
self.conn = None
self.read_settings()
self.run()
def _connect(self):
if not self.conn:
auth = MAASOAuth(*self.maas_api_key.split(':'))
dispatcher = MAASDispatcher()
self.maas_client = MAASClient(auth, dispatcher, self.maas_url)
self.conn = True
def read_settings(self):
""" Reads the settings from the maansible.ini file """
config = ConfigParser.SafeConfigParser()
config.read(
os.path.dirname(os.path.realpath(__file__)) + '/maansible.ini')
self.maas_url = config.get('maas', 'url')
self.maas_api_key = config.get('maas', 'api_key')
self.tags = dict(config.items('tags'))
def run(self):
""" Make calls to Maas to create tags and assign nodes to them """
self._connect()
# Get system ids of nodes
nodes = self.maas_client.get('/nodes/', 'list').read()
system_ids = {}
for node in json.loads(nodes):
system_ids[node['hostname'].split('.')[0]] = node['system_id']
# Get existing tags
tags = self.maas_client.get('/tags/', 'list').read()
tags = [tag['name'] for tag in json.loads(tags)]
# Create tags if not existing and apply them
for tag in self.tags:
if not tag in tags:
params = {'name': tag}
self.maas_client.post('/tags/', 'new', **params)
nodes = self.tags[tag].split(',')
for node in nodes:
params = {'add': system_ids[node]}
self.maas_client.post('/tags/%s/' % tag, 'update_nodes',
**params)
class MaasTagging(object):
def __init__(self):
""" Main execution path """
self.conn = None
self.read_settings()
self.run()
def _connect(self):
if not self.conn:
auth = MAASOAuth(*self.maas_api_key.split(':'))
dispatcher = MAASDispatcher()
self.maas_client = MAASClient(auth, dispatcher, self.maas_url)
self.conn = True
def read_settings(self):
""" Reads the settings from the maansible.ini file """
config = ConfigParser.SafeConfigParser()
config.read(os.path.dirname(os.path.realpath(__file__)) + '/maansible.ini')
self.maas_url = config.get('maas', 'url')
self.maas_api_key = config.get('maas', 'api_key')
self.tags = dict(config.items('tags'))
def run(self):
""" Make calls to Maas to create tags and assign nodes to them """
self._connect()
# Get system ids of nodes
nodes = self.maas_client.get('/nodes/', 'list').read()
system_ids = {}
for node in json.loads(nodes):
system_ids[node['hostname'].split('.')[0]] = node['system_id']
# Get existing tags
tags = self.maas_client.get('/tags/', 'list').read()
tags = [tag['name'] for tag in json.loads(tags)]
# Create tags if not existing and apply them
for tag in self.tags:
if not tag in tags:
params = {'name': tag}
self.maas_client.post('/tags/', 'new', **params)
nodes = self.tags[tag].split(',')
for node in nodes:
params = {'add': system_ids[node]}
self.maas_client.post('/tags/%s/' % tag, 'update_nodes', **params)
def determine_cluster_interfaces(knowledge):
"""Given server knowledge, determine network interfaces on this cluster.
:return: a list of tuples of (interface name, ip) for all interfaces.
:note: this uses an API call and not local probing because the
region controller has the definitive and final say in what does and
doesn't exist.
"""
api_path = 'api/1.0/nodegroups/%s/interfaces' % knowledge['nodegroup_uuid']
oauth = MAASOAuth(*knowledge['api_credentials'])
client = MAASClient(oauth, MAASDispatcher(), knowledge['maas_url'])
interfaces = process_request(client.get, api_path, 'list')
if interfaces is None:
return None
interface_names = sorted((interface['interface'], interface['ip'])
for interface in interfaces
if interface['interface'] != '')
return interface_names
def send_leases(leases):
"""Send lease updates to the server API."""
# Items that the server must have sent us before we can do this.
knowledge = {
'maas_url': get_maas_url(),
'api_credentials': get_recorded_api_credentials(),
'nodegroup_uuid': get_recorded_nodegroup_uuid(),
}
if None in knowledge.values():
# The MAAS server hasn't sent us enough information for us to do
# this yet. Leave it for another time.
logger.info(
"Not sending DHCP leases to server: not all required knowledge "
"received from server yet. "
"Missing: %s" % ', '.join(list_missing_items(knowledge)))
return
api_path = 'api/1.0/nodegroups/%s/' % knowledge['nodegroup_uuid']
oauth = MAASOAuth(*knowledge['api_credentials'])
MAASClient(oauth, MAASDispatcher(),
knowledge['maas_url']).post(api_path,
'update_leases',
leases=json.dumps(leases))
class FabricMAAS(object):
CORD_TEST_HOST = '172.17.0.1'
head_node = os.getenv('HEAD_NODE', CORD_TEST_HOST)
maas_url = 'http://{}/MAAS/api/1.0/'.format(head_node)
def __init__(self, api_key=None, url=maas_url):
if api_key == None:
self.api_key = self.get_api_key()
else:
self.api_key = api_key
self.auth = MAASOAuth(*self.api_key.split(':'))
self.url = url
self.client = MAASClient(self.auth, MAASDispatcher(), self.url)
@classmethod
def get_api_key(cls):
api_key = os.getenv('MAAS_API_KEY', None)
if api_key:
return api_key
cmd = ['maas-region-admin', 'apikey', '--username=cord']
try:
p = subprocess.Popen(cmd,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
except:
return 'UNKNOWN'
out, err = p.communicate()
if err:
raise Exception('Cannot get api key for MAAS')
return out.strip()
def get_node_list(self):
nodes = self.client.get(u'nodes/', 'list').read()
node_list = json.loads(nodes)
hosts = [self.head_node] + map(lambda n: n['hostname'], node_list)
return hosts
def _auth(**connection_args):
'''
Set up maas credentials
Only intended to be used within maas-enabled modules
'''
prefix = "maas."
# look in connection_args first, then default to config file
def get(key, default=None):
return connection_args.get(
'connection_' + key, __salt__['config.get'](prefix + key, default))
api_token = get('token')
api_url = get('url', 'https://localhost/')
LOG.debug("MAAS url: " + api_url)
LOG.debug("MAAS token: " + api_token)
auth = MAASOAuth(*api_token.split(":"))
dispatcher = MAASDispatcher()
client = MAASClient(auth, dispatcher, api_url)
return client
def _connect(self):
if not self.conn:
auth = MAASOAuth(*self.maas_api_key.split(':'))
dispatcher = MAASDispatcher()
self.maas_client = MAASClient(auth, dispatcher, self.maas_url)
self.conn = True
def fake_client(self):
return MAASClient(None, None, self.make_maas_url())
def fake_client(self):
return MAASClient(None, None, factory.make_simple_http_url())
class MaasInventory(object):
def __init__(self):
""" Main execution path """
self.conn = None
self.inventory = dict() # A list of groups and the hosts in that group
self.cache = dict() # Details about hosts in the inventory
# Read settings and parse CLI arguments
self.read_settings()
self.parse_cli_args()
# Cache
if self.args.refresh_cache:
self.update_cache()
elif not self.is_cache_valid():
self.update_cache()
else:
self.load_inventory_from_cache()
self.load_cache_from_cache()
data_to_print = ""
# Data to print
if self.args.host:
data_to_print = self.get_host_info()
elif self.args.list:
# Display list of instances for inventory
data_to_print = self.json_format_dict(self.inventory, True)
else: # default action with no options
data_to_print = self.json_format_dict(self.inventory, True)
print data_to_print
def _connect(self):
if not self.conn:
auth = MAASOAuth(*self.maas_api_key.split(':'))
dispatcher = MAASDispatcher()
self.maas_client = MAASClient(auth, dispatcher, self.maas_url)
self.conn = True
def is_cache_valid(self):
""" Determines if the cache files have expired, or if it is still valid """
if os.path.isfile(self.cache_path_cache):
mod_time = os.path.getmtime(self.cache_path_cache)
current_time = time()
if (mod_time + self.cache_max_age) > current_time:
if os.path.isfile(self.cache_path_inventory):
return True
return False
def read_settings(self):
""" Reads the settings from the maansible.ini file """
config = ConfigParser.SafeConfigParser()
config.read(os.path.dirname(os.path.realpath(__file__)) + '/maansible.ini')
self.maas_url = config.get('maas', 'url')
self.maas_api_key = config.get('maas', 'api_key')
self.tags = dict(config.items('tags'))
family = dict(config.items('family'))
groups = []
for parent in family:
group = {
'name': parent,
'children': family[parent].split(','),
'vars': dict(config.items(parent+':vars'))
}
groups.append(group)
self.ansible_groups = groups
host_vars = dict(config.items('host:vars'))
host_vars['devices'] = host_vars['devices'].split(',')
host_vars['raw_journal_devices'] = host_vars['raw_journal_devices'].split(',')
self.ansible_host_vars = host_vars
# Cache related
cache_path = config.get('maas', 'cache_path')
self.cache_path_cache = cache_path + "/ansible-maas.cache"
self.cache_path_inventory = cache_path + "/ansible-maas.index"
self.cache_max_age = config.getint('maas', 'cache_max_age')
def parse_cli_args(self):
""" Command line argument processing """
parser = argparse.ArgumentParser(description='Produce an Ansible Inventory file based on Maas')
parser.add_argument('--list', action='store_true', default=True, help='List instances (default: True)')
parser.add_argument('--host', action='store', help='Get all the variables about a specific instance')
parser.add_argument('--refresh-cache', action='store_true', default=False,
help='Force refresh of cache by making API requests to Maas (default: False - use cache files)')
self.args = parser.parse_args()
def update_cache(self):
""" Make calls to Maas and save the output in a cache """
self._connect()
self.groups = dict()
self.hosts = dict()
hostvars = dict()
for tag in self.tags:
nodes = self.maas_client.get('/tags/' + tag, 'nodes').read()
nodes = json.loads(nodes)
hosts = []
for node in nodes:
hostname = node['hostname']
ip_address = node['ip_addresses'][0]
if not hostname in hostvars:
hostvars[hostname] = dict()
hostvars[hostname].update(self.ansible_host_vars)
hostvars[hostname]['ansible_ssh_host'] = ip_address
hosts.append(hostname)
self.inventory[tag] = {'hosts': hosts}
self.inventory['_meta'] = {'hostvars': hostvars}
for group in self.ansible_groups:
self.inventory[group['name']] = {
'children': group['children'],
'vars': group['vars']
}
self.write_to_cache(self.cache, self.cache_path_cache)
self.write_to_cache(self.inventory, self.cache_path_inventory)
def get_host_info(self):
""" Get variables about a specific host """
if not self.cache or len(self.cache) == 0:
# Need to load index from cache
self.load_cache_from_cache()
if not self.args.host in self.cache:
# try updating the cache
self.update_cache()
if not self.args.host in self.cache:
# host might not exist anymore
return self.json_format_dict({}, True)
return self.json_format_dict(self.cache[self.args.host], True)
def push(self, my_dict, key, element):
""" Pushed an element onto an array that may not have been defined in the dict """
if key in my_dict:
my_dict[key].append(element)
else:
my_dict[key] = [element]
def load_inventory_from_cache(self):
""" Reads the index from the cache file sets self.index """
cache = open(self.cache_path_inventory, 'r')
json_inventory = cache.read()
self.inventory = json.loads(json_inventory)
def load_cache_from_cache(self):
""" Reads the cache from the cache file sets self.cache """
cache = open(self.cache_path_cache, 'r')
json_cache = cache.read()
self.cache = json.loads(json_cache)
def write_to_cache(self, data, filename):
""" Writes data in JSON format to a file """
json_data = self.json_format_dict(data, True)
cache = open(filename, 'w')
cache.write(json_data)
cache.close()
def to_safe(self, word):
""" Converts 'bad' characters in a string to underscores so they can be used as Ansible groups """
return re.sub("[^A-Za-z0-9\-]", "_", word)
def json_format_dict(self, data, pretty=False):
""" Converts a dict to a JSON object and dumps it as a formatted string """
if pretty:
return json.dumps(data, sort_keys=True, indent=2)
else:
return json.dumps(data)
def get_client(url, creds):
[consumer_key, token, secret] = creds.split(':')
auth = MAASOAuth(consumer_key=consumer_key,
resource_token=token,
resource_secret=secret)
return MAASClient(auth, MAASDispatcher(), url)
def _connect(self):
if not self.conn:
auth = MAASOAuth(*self.maas_api_key.split(':'))
dispatcher = MAASDispatcher()
self.maas_client = MAASClient(auth, dispatcher, self.maas_url)
self.conn = True
def make_anonymous_api_client(server_url):
"""Create an unauthenticated API client."""
return MAASClient(NoAuth(), MAASDispatcher(), server_url)
def _getclient(url=u'http://localhost/MAAS/api/1.0/'):
consumer_key, token, secret = key('root').split(':', 3)
auth = MAASOAuth(consumer_key, token, secret)
dispatch = MAASDispatcher()
client = MAASClient(auth, dispatch, url)
return client