chef.py

from __future__ import unicode_literals

import json
import os.path
import re
import subprocess
import time

from celery.canvas import group

from api.ssh import exec_ssh, connect_ssh
from cm.chef_api import ChefAPI


CHEF_CONFIG_PATH = '/etc/chef'
CHEF_INSTALL_TYPE = 'gems'
CHEF_RUBY_VERSION = '1.9.1'
CHEF_ENVIRONMENT = '_default'
CHEF_CLIENT_VERSION = '11.4.4'

# load chef config using CHEF_CONFIG_PATH
try:
    # parse controller's chef config for server_url and client_name
    _client_cfg_path = os.path.join(CHEF_CONFIG_PATH, 'client.rb')
    if not os.path.exists(_client_cfg_path):
        raise EnvironmentError('Could not find {}'.format(_client_cfg_path))
    with open(_client_cfg_path) as f:
        _data = f.read()
    # construct a dict from the ruby client.rb
    _d = {}
    for m in re.findall(r'''^([a-zA-Z0-9_]+)[ \t]+(.*)$''',
                        _data, re.MULTILINE):
        _d[m[0]] = m[1].strip("'").strip('"')
    # set global variables from client.rb
    CHEF_SERVER_URL = _d['chef_server_url']
    CHEF_NODE_NAME = _d['node_name']
    CHEF_CLIENT_NAME = _d['node_name']
    CHEF_VALIDATION_NAME = _d['validation_client_name']
    # read the client key
    _client_pem_path = os.path.join(CHEF_CONFIG_PATH, 'client.pem')
    CHEF_CLIENT_KEY = subprocess.check_output(
        ['sudo', '/bin/cat', _client_pem_path]).strip('\n')
    # read the validation key
    _valid_pem_path = os.path.join(CHEF_CONFIG_PATH, 'validation.pem')
    CHEF_VALIDATION_KEY = subprocess.check_output(
        ['sudo', '/bin/cat', _valid_pem_path]).strip('\n')
except Exception as e:
    raise EnvironmentError('Failed to auto-configure Chef -- {}'.format(e))


def _get_client():
    """
    Return a new instance of a Chef API Client
    """
    return ChefAPI(CHEF_SERVER_URL, CHEF_CLIENT_NAME, CHEF_CLIENT_KEY)


def configure_node(node):
    config = node.layer.config.copy()
    # http://cloudinit.readthedocs.org/en/latest/topics/examples.html#install-and-run-chef-recipes
    chef = config['chef'] = {}
    chef['node_name'] = node.id
    # if run_list specified in layer, use it (assumes csv)
    run_list = node.layer.config.get('run_list', [])
    if run_list:
        chef['run_list'] = run_list.split(',')
    # otherwise construct a run_list using proxy/runtime flags
    else:
        run_list = ['recipe[deis]']
        if node.layer.runtime is True:
            run_list.append('recipe[deis::runtime]')
        if node.layer.proxy is True:
            run_list.append('recipe[deis::proxy]')
        chef['run_list'] = run_list
    attrs = node.layer.config.get('initial_attributes')
    if attrs:
        chef['initial_attributes'] = attrs
    # add global chef config
    chef['version'] = CHEF_CLIENT_VERSION
    chef['ruby_version'] = CHEF_RUBY_VERSION
    chef['server_url'] = CHEF_SERVER_URL
    chef['install_type'] = CHEF_INSTALL_TYPE
    chef['environment'] = CHEF_ENVIRONMENT
    chef['validation_name'] = CHEF_VALIDATION_NAME
    chef['validation_key'] = CHEF_VALIDATION_KEY
    return config


def bootstrap_node(node):
    # loop until node is registered with chef
    # if chef bootstrapping fails, the node will not complete registration
    registered = False
    while not registered:
        # reinstatiate the client on each poll attempt
        # to avoid disconnect errors
        client = _get_client()
        resp, status = client.get_node(node.id)
        if status == 200:
            body = json.loads(resp)
            # wait until idletime is not null
            # meaning the node is registered
            if body.get('automatic', {}).get('idletime'):
                break
        time.sleep(5)
    return node


def destroy_node(node):
    """
    Purge the Node & Client records from Chef Server
    """
    client = _get_client()
    client.delete_node(node.id)
    client.delete_client(node.id)
    return node


def update_user(user):
    client = _get_client()
    # client.create_databag_item('deis-users', user.username, user.calculate())
    client.update_databag_item('deis-users', user.username, user.calculate())


def update_app(app):
    client = _get_client()
    client.update_databag_item('deis-apps', app.id, app.calculate())


def update_formation(formation, client):
    client.update_databag_item('deis-formations', formation.id, formation.calculate())


def converge_controller():
    # NOTE: converging the controller can overwrite any in-place
    # changes to application code
    try:
        return subprocess.check_output(
            ['sudo', 'chef-client', '--override-runlist', 'recipe[deis::gitosis]'])
    except subprocess.CalledProcessError as e:
        print(e)
        print(e.output)
        raise e


def converge_node(node):
    ssh = connect_ssh(node.layer.ssh_username,
                      node.fqdn, 22,
                      node.layer.ssh_private_key)
    output, rc = exec_ssh(ssh, 'sudo chef-client')
    return output, rc


def converge_formation(formation):
    nodes = formation.node_set.all()
    subtasks = []
    for n in nodes:
        subtask = converge_node.s(n.id,
                                  n.layer.flavor.ssh_username,
                                  n.fqdn,
                                  n.layer.flavor.ssh_private_key)
        subtasks.append(subtask)
    job = group(*subtasks)
    return job.apply_async().join()


def publish_user(username, data):
    _publish('deis-users', username, data)
    return username


def publish_app(app_id, data):
    _publish('deis-apps', app_id, data)
    return app_id


def purge_app(app_id):
    _purge('deis-apps', app_id)
    return app_id


def publish_formation(formation_id, data):
    _publish('deis-formations', formation_id, data)
    return formation_id


def purge_formation(formation_id):
    _purge('deis-formations', formation_id)
    return formation_id


def _publish(data_bag, item_name, item_value):
    client = _get_client()
    body, status = client.update_databag_item(data_bag, item_name, item_value)
    if status != 200:
        body, status = client.create_databag_item(data_bag, item_name, item_value)
        if status != 201:
            raise RuntimeError('Could not publish {item_name}: {body}'.format(**locals()))
    return body, status


def _purge(databag_name, item_name):
    client = _get_client()
    body, status = client.delete_databag_item(databag_name, item_name)
    if status == 200 or status == 404:
        return body, status
    raise RuntimeError('Could not purge {item_name}: {body}'.format(**locals()))