Esempio n. 1
0
def interrogate_hypervisor():
    authenticator = request.form.get("password")
    if authenticator is not None:
        auth_type = "auth_type_password"
    else:
        auth_type = "auth_type_ssh"
        authenticator = TEMP_DIR + "/hypervisor.key"

    host = request.form['host']

    profile_results = stick_actions.profile_host("root", auth_type, authenticator, host)

    return_val = {}
    return_disk = {}
    return_mem = {}
    return_has_admin = {}
    return_platform_image_ok = {}
    return_dns_lookup_ok = {}
    return_threads = {}

    return_disk['value'] = str(profile_results['disk']) + 'G'
    if profile_results["disk"] >= stick_const.hyper_min_disk_min:
        return_disk['status'] = 'ok'
    else:
        return_disk['status'] = 'error'

    return_mem['value'] = str(profile_results['mem']) + 'G'
    if profile_results["mem"] >= stick_const.hyper_min_ram_min:
        return_mem['status'] = 'ok'
    else:
        return_mem['status'] = 'error'

    return_has_admin['value'] = profile_results['has_admin']
    if profile_results["has_admin"] == True:
        return_has_admin['status'] = 'ok'
    else:
        return_has_admin['status'] = 'error'

    return_dns_lookup_ok['value'] = profile_results['dns_lookup_ok']
    if profile_results["dns_lookup_ok"] == True:
        return_dns_lookup_ok['status'] = 'ok'
    else:
        return_dns_lookup_ok['status'] = 'error'

    return_platform_image_ok['value'] = profile_results['platform_image_ok']
    if profile_results["platform_image_ok"] == True:
        return_platform_image_ok['status'] = 'ok'
    else:
        return_platform_image_ok['status'] = 'warning'

    return_threads['value'] = profile_results['threads']
    return_threads['status'] = 'ok'

    return_threads['value'] = profile_results['threads']
    return_threads['status'] = 'ok'



    return_val['disk'] = return_disk
    return_val['mem'] = return_mem
    return_val['has_admin'] = return_has_admin
    return_val['dns_lookup_ok'] = return_dns_lookup_ok
    return_val['platform_image_ok'] = return_platform_image_ok
    return_val['threads'] = return_threads
    return_val['result'] = "ok"



    return jsonify(return_val)
Esempio n. 2
0
def install_fifo():
    authenticator = request.form.get("password")
    if authenticator is not None:
        auth_type = "auth_type_password"
    else:
        auth_type = "auth_type_ssh"
        authenticator = TEMP_DIR + "/hypervisor.key"

    hypervisors = []
    hypervisors = request.form.getlist("hypervisors[]")
    adminNetStart = request.form.get("adminNetStart")
    adminNetEnd = request.form.get("adminNetEnd")
    leoNodeCount = request.form.get("leoNodes")
    leoReplicaN = request.form.get("leoReplicaN")
    leoReplicaR = request.form.get("leoReplicaR")
    leoReplicaW = request.form.get("leoReplicaW")
    leoReplicaD = request.form.get("leoReplicaD")

    host_netconfig = stick_utility.network_host()
    assignableIpNetwork = IPNetwork(host_netconfig['gateway'] + '/' + host_netconfig['netmask'])
    assignableIpRange = list(iter_iprange(adminNetStart, adminNetEnd))

    fifo_cookie = ''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(20))
    leo_cookie = ''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(20))

        # hypervisors = []
        # hypervisors = request.form.getlist("hypervisors[]")
        #
        # leoNodeCount = request.form.get("leoNodes")
        #
        # placements = stick_actions.recomend_vm_placements(hypervisors, leoNodeCount)
        #
        # if placements is None:
        #     return_val = {}
        #     return_val['result'] = "error"
        #     return
        #



    print 'Profiling hypervisors...'
    hypervisor_profiles = []
    for hypervisor in hypervisors:
        hypervisor_profiles.append(stick_actions.profile_host(
            "root",
            auth_type,
            authenticator,
            hypervisor))

    print 'Generating VM sizes and placements...'
    hypervisor_sizing = {}
    for hypervisor in hypervisor_profiles:
        if hypervisor["mem"] >= stick_const.hyper_min_ram_good and \
           hypervisor["disk"] >= stick_const.hyper_min_disk_min:
            hypervisor_sizing[hypervisor["host"]] = stick_const.vm_sizing_good
        else:
            hypervisor_sizing[hypervisor["host"]] = stick_const.vm_sizing_min

    placements = stick_actions.recomend_vm_placements(hypervisors, leoNodeCount)

    if placements is None:
        return "error - could not create placements"





    # TODO: DEPLOY DATASET TO HYPERS

    print 'Creating first Fifo zone...'

    placement_index = next(
        index for (index, d) in enumerate(placements)
        if '1.fifo' in d)
    fifo_1_placement = placements[placement_index]['1.fifo']
    fifo_1_sizing = hypervisor_sizing[fifo_1_placement]

    stick_templates.zone_definition(
        '/tmp/1.fifo.json',
        fifo_1_sizing['fifo_zone_mem'],
        100,
        fifo_1_sizing['fifo_zone_disk'],
        '1.fifo',
        "1",
        adminNetStart,
        host_netconfig['gateway'],
        host_netconfig['netmask'],
        ['8.8.8.8', '8.8.4.4'],
        TEMP_DIR + '/vm.pub')

    if not stick_actions.create_zone("root@" + fifo_1_placement,
                                     '/tmp/1.fifo.json'):
        print "There was an error createing the first machine."
        print "Aborting... Some changes possibly made to hypervisor: " + fifo_1_placement
        return "error - see logs"
    print 'VM "1.fifo" created on ' + fifo_1_placement

    print 'Configuring Fetch for Fifo'
    stick_actions.apply_properties(FETCH_DIR, 'fifo-sniffle',
                                   {'sniffle_cookie': fifo_cookie})
    stick_actions.apply_properties(FETCH_DIR, 'fifo-snarl', {'snarl_cookie': fifo_cookie})
    stick_actions.apply_properties(FETCH_DIR, 'fifo-howl', {'howl_cookie': fifo_cookie})
    stick_actions.apply_properties(FETCH_DIR, 'fifo-wiggle', {'wiggle_cookie': fifo_cookie})
    stick_actions.apply_properties(FETCH_DIR, 'fifo-chunter', {'chunter_cookie': fifo_cookie})

    print 'Installing fifo on vm'

    if not stick_actions.apply_role(FETCH_DIR, "fifo-wiggle",
                                    str(assignableIpRange[0]),
                                    TEMP_DIR + '/vm.key',
                                    'transport=paramiko') == True:
        return "error - could not apply wiggle role"

    if not stick_actions.apply_role(FETCH_DIR, "fifo-jingles",
                                    str(assignableIpRange[0]),
                                    TEMP_DIR + '/vm.key',
                                    'transport=paramiko') == True:
        return "error - could not apply jingles role"

    if not stick_actions.apply_role(FETCH_DIR, "fifo-howl",
                                    str(assignableIpRange[0]),
                                    TEMP_DIR + '/vm.key',
                                    'transport=paramiko') == True:
        return "error - could not apply howl role"

    if not stick_actions.apply_role(FETCH_DIR, "fifo-sniffle",
                                    str(assignableIpRange[0]),
                                    TEMP_DIR + '/vm.key',
                                    'transport=paramiko') == True:
        return "error - could not apply sniffle role"

    if not stick_actions.apply_role(FETCH_DIR, "fifo-snarl",
                                    str(assignableIpRange[0]),
                                    TEMP_DIR + '/vm.key',
                                    'transport=paramiko') == True:
        return "error - could not apply snarl role"




    # TODO: change from set time to a poll
    print 'Pausing for Fifo services to connect...'
    time.sleep(20)

    print 'Creating admin user in Fifo...'
    stick_actions.create_fifo_user(str(assignableIpRange[0]),
                                   "auth_type_ssh", TEMP_DIR + '/vm.key',
                                   "admin", "admin")

    print 'Creating pyfi config...'
    stick_templates.pyfi_config(adminNetStart, "admin", "admin")

    # TODO: add admin ssh key  - fifo

    print 'Creating admin network...'
    admin_network_uuid = stick_actions.create_fifo_network("Admin")
    if not admin_network_uuid:
        return "error - could not create admin network"


    #admin_network_ip = IPSet(IPRange(host_netconfig['gateway'], host_netconfig['netmask']))[0]
    admin_network_ip = str(assignableIpNetwork.network)

    admin_iprange_uuid = stick_actions.create_fifo_iprange(
        adminNetStart + "-" + adminNetEnd,
        admin_network_ip,
        host_netconfig['netmask'],
        host_netconfig['gateway'],
        adminNetStart,
        adminNetEnd,
        "admin")

    if not admin_iprange_uuid:
        return "error - could not create admin network ip range"

    admin_link_network_result = stick_actions.link_fifo_net_range(
        admin_network_uuid,
        admin_iprange_uuid)
    if not admin_link_network_result:
        return "error - could not add ip range to network"



    # TODO: create default packages  - fifo
    #
    # TODO: create fifo cluster  - fifo
    # add to fifo ring  - fabric
    # create fifo zones  - fifo
    # create leo cluster  - fifo


    print 'Configuring Fetch for Leo'
    leofs_manager_vars = {
        'leofs_cookie': leo_cookie,
        'leofs_master': 'manager0@' + str(assignableIpRange[1]),
        'leofs_slave': 'manager1@' + str(assignableIpRange[2]),
        'leofs_replicaN': str(leoReplicaN),
        'leofs_replicaR': str(leoReplicaR),
        'leofs_replicaW': str(leoReplicaW),
        'leofs_replicaD': str(leoReplicaD),
        'leofs_replicaRAR': '0'
    }

    leofs_gateway_vars = {
        'leofs_cookie': leo_cookie,
        'leofs_master': 'manager0@' + str(assignableIpRange[1]),
        'leofs_slave': 'manager1@' + str(assignableIpRange[2]),
    }

    leofs_storage_vars = {
        'leofs_cookie': leo_cookie,
        'leofs_master': 'manager0@' + str(assignableIpRange[1]),
        'leofs_slave': 'manager1@' + str(assignableIpRange[2]),
    }

    stick_actions.apply_properties(FETCH_DIR, 'leofs-manager', leofs_manager_vars)
    stick_actions.apply_properties(FETCH_DIR, 'leofs-gateway', leofs_gateway_vars)
    stick_actions.apply_properties(FETCH_DIR, 'leofs-storage', leofs_storage_vars)


    print 'Creating 1.manager.leofs zone...'
    X = next(index for (index, d) in enumerate(placements) if '1.manager.leofs' in d)
    leomngr_1_placement = placements[X]['1.manager.leofs']
    leomngr_1_sizing = hypervisor_sizing[leomngr_1_placement]

    stick_templates.zone_definition(
        '/tmp/1.manager.leofs',
        leomngr_1_sizing['leo_mngr_mem'],
        100,
        leomngr_1_sizing['leo_mngr_disk'],
        '1.manager.leofs',
        "1",
        str(assignableIpRange[1]),
        host_netconfig['gateway'],
        host_netconfig['netmask'],
        ['8.8.8.8', '8.8.4.4'],
        TEMP_DIR + '/vm.pub')

    if not stick_actions.create_zone("root@" + leomngr_1_placement, '/tmp/1.manager.leofs'):
        return "error - could not create 1.manager.leofs"
    print 'VM "1.manager.leofs" created on ' + leomngr_1_placement



    print 'Creating 2.manager.leofs zone...'
    X = next(index for (index, d) in enumerate(placements) if '2.manager.leofs' in d)
    leomngr_2_placement = placements[X]['2.manager.leofs']
    leomngr_2_sizing = hypervisor_sizing[leomngr_2_placement]

    stick_templates.zone_definition(
        '/tmp/2.manager.leofs',
        leomngr_2_sizing['leo_mngr_mem'],
        100,
        leomngr_2_sizing['leo_mngr_disk'],
        '2.manager.leofs',
        "1",
        str(assignableIpRange[2]),
        host_netconfig['gateway'],
        host_netconfig['netmask'],
        ['8.8.8.8', '8.8.4.4'],
        TEMP_DIR + '/vm.pub')

    if not stick_actions.create_zone("root@" + leomngr_2_placement, '/tmp/2.manager.leofs'):
        return "error - could not create 2.manager.leofs"
    print 'VM "2.manager.leofs" created on ' + leomngr_2_placement

    print 'Applying roles to LeoFS managers'
    if not (
            stick_actions.apply_role(
                FETCH_DIR,
                "leofs-manager",
                str(assignableIpRange[1]),
                TEMP_DIR + '/vm.key',
                'transport=paramiko nodename=manager0@' + str(assignableIpRange[1]))
        ) == True:
        return "error - could not apply Leofs manager role to manager 0"

    if not (
            stick_actions.apply_role(
                FETCH_DIR,
                "leofs-manager",
                str(assignableIpRange[2]),
                TEMP_DIR + '/vm.key',
                'transport=paramiko nodename=manager1@' + str(assignableIpRange[2]))
        ) == True:
        return "error - could not apply Leofs manager role to manager 1"


    print 'Creating 1.gateway.leofs zone...'
    X = next(index for (index, d) in enumerate(placements) if '1.gateway.leofs' in d)
    leogate_1_placement = placements[X]['1.gateway.leofs']
    leogate_1_sizing = hypervisor_sizing[leogate_1_placement]

    stick_templates.zone_definition(
        '/tmp/1.gateway.leofs',
        leogate_1_sizing['leo_gate_mem'],
        100,
        leogate_1_sizing['leo_gate_disk'],
        '1.gateway.leofs',
        "1",
        str(assignableIpRange[3]),
        host_netconfig['gateway'],
        host_netconfig['netmask'],
        ['8.8.8.8', '8.8.4.4'],
        TEMP_DIR + '/vm.pub')


    leo_vm_iterator = 0
    while leo_vm_iterator < int(leoNodeCount):
        leo_vm_iterator = leo_vm_iterator + 1
        node_name = str(leo_vm_iterator) + ".storage.leofs"

        print 'Creating ' + node_name + ' zone...'
        X = next(index for (index, d) in enumerate(placements) if node_name in d)
        leostorage_placement = placements[X][node_name]
        leostorage_sizing = hypervisor_sizing[leogate_1_placement]

        stick_templates.zone_definition(
            '/tmp/' + node_name,
            leostorage_sizing['leo_store_mem'],
            100,
            leostorage_sizing['leo_store_disk'],
            node_name,
            "1",
            str(assignableIpRange[(leo_vm_iterator + 3)]),
            host_netconfig['gateway'],
            host_netconfig['netmask'],
            ['8.8.8.8', '8.8.4.4'],
            TEMP_DIR + '/vm.pub')

        if not (
                stick_actions.create_zone("root@" + leostorage_placement,
                                          '/tmp/' + node_name)):
            return "error - could not create " + node_name
        print 'VM "' + node_name + '" created on ' + leostorage_placement
        role_options = ('transport=paramiko nodename=storage' +
                        str(leo_vm_iterator-1) +
                        '@' +
                        str(assignableIpRange[(leo_vm_iterator + 3)]))
        if not (
                stick_actions.apply_role(
                    FETCH_DIR,
                    "leofs-storage",
                    str(assignableIpRange[(leo_vm_iterator + 3)]),
                    TEMP_DIR + '/vm.key',
                    role_options)
            ) == True:
            return "error - could not apply Leofs storage role to storage " + str(leo_vm_iterator-1)


    print 'Starting LeoFS storage ring...'
    if not (
            stick_actions.start_leofs_storage(
                str(assignableIpRange[1]),
                "auth_type_ssh",
                TEMP_DIR + '/vm.key')
        ) == True:
        return "error - could not start Leofs storage ring"


    if not stick_actions.create_zone("root@" + leogate_1_placement,
                                     '/tmp/1.gateway.leofs'):
        return "error - could not create 1.gateway.leofs"
    print 'VM "1.gateway.leofs" created on ' + leogate_1_placement

    print 'Applying roles to LeoFS gateway'
    if not (
            stick_actions.apply_role(
                FETCH_DIR,
                "leofs-gateway",
                str(assignableIpRange[3]),
                TEMP_DIR + '/vm.key',
                'transport=paramiko nodename=gateway0@' + str(assignableIpRange[3]))
        ) == True:
        return "error - could not apply Leofs gateway role to gateway 0"

        
    print 'Configuring Fifo to use LeoFS...'
    if not (
            stick_actions.init_fifo_leofs(
                str(assignableIpRange[0]),
                "auth_type_ssh",
                TEMP_DIR + '/vm.key',
                str(assignableIpRange[1]) + ".xip.io")
        ) == True:
        return "error - could not initialize leofs storage"

    if not (
            stick_actions.add_leofs_endpoint(
                str(assignableIpRange[1]),
                "auth_type_ssh",
                TEMP_DIR + '/vm.key',
                str(assignableIpRange[3]) + ".xip.io")
        ) == True:
        return "error - could not create endpoint in leofs"

    if not (
            stick_actions.config_fifo_sniffle(
                str(assignableIpRange[0]),
                "auth_type_ssh",
                TEMP_DIR + '/vm.key',
                'storage.s3.host',
                str(assignableIpRange[3]) + ".xip.io")
        ) == True:
        return "error - could not change leofs host in sniffle"


    ip_claim_iterator = 0
    while ip_claim_iterator < (int(leoNodeCount) + 4):
        stick_actions.claim_fifo_ip(
            str(assignableIpRange[0]),
            "auth_type_ssh",
            TEMP_DIR + '/vm.key',
            admin_iprange_uuid)
        ip_claim_iterator = ip_claim_iterator + 1


    stick_actions.create_hypervisor_inventory(FETCH_DIR, hypervisors)

    if auth_type == "auth_type_password":
        stick_actions.run_playbook_with_pass(
            FETCH_DIR + '/hypervisors.yml',
            FETCH_DIR + '/inventory/hypervisors',
            authenticator)
    else:
        stick_actions.run_playbook(FETCH_DIR + '/hypervisors.yml',
                                   FETCH_DIR + '/inventory/hypervisors')

    return jsonify({'result': 'ok'})