示例#1
0
def storages(request, host_id):
    """
    Storage pool block
    """
    errors = []
    compute = Compute.objects.get(id=host_id)

    try:
        conn = wvmStorages(compute.hostname, compute.login, compute.password,
                           compute.type)
        storages = conn.get_storages_info()
        secrets = conn.get_secrets()

        if request.method == 'POST':
            if 'create' in request.POST:
                form = AddStgPool(request.POST)
                if form.is_valid():
                    data = form.cleaned_data
                    if data['name'] in storages:
                        msg = _("Pool name already use")
                        errors.append(msg)
                    if data['stg_type'] == 'rbd':
                        if not data['secret']:
                            msg = _("You need create secret for pool")
                            errors.append(msg)
                        if not data['ceph_pool'] and not data[
                                'ceph_host'] and not data['ceph_user']:
                            msg = _(
                                "You need input all fields for creating ceph pool"
                            )
                            errors.append(msg)
                    if not errors:
                        if data['stg_type'] == 'rbd':
                            conn.create_storage_ceph(data['stg_type'],
                                                     data['name'],
                                                     data['ceph_pool'],
                                                     data['ceph_host'],
                                                     data['ceph_user'],
                                                     data['secret'])
                        else:
                            conn.create_storage(data['stg_type'], data['name'],
                                                data['source'], data['target'])
                        url = '/%s/storage/%s/' % (host_id, data['name'])
                        object = {'response': {}}
                        return redirect_or_json(object, url, request)
                else:
                    errors = [error for error in form.errors]

        conn.close()
    except libvirtError as err:
        errors.append(err)

    object = {
        'response': {
            'storages': storages,
            'secrets': secrets,
        },
        'errors': [str(error) for error in errors]
    }
    return render(object, 'storages.html', locals(), request)
示例#2
0
def networks(request, host_id):
    """
    Networks block
    """
    errors = []
    object = {}

    try:
        compute = Compute.objects.get(id=host_id)

        conn = wvmNetworks(compute.hostname, compute.login, compute.password,
                           compute.type)
        networks = conn.get_networks_info()

        if request.method == 'POST':
            if 'create' in request.POST:
                form = AddNetPool(request.POST)
                if form.is_valid():
                    data = form.cleaned_data
                    if data['name'] in networks:
                        msg = ("Pool name already in use")
                        errors.append(msg)
                    if data['forward'] == 'bridge' and data[
                            'bridge_name'] == '':
                        errors.append('Please enter bridge name')
                    try:
                        gateway, netmask, dhcp = network_size(
                            data['subnet'], data['dhcp'])
                    except:
                        msg = ("Input subnet pool error")
                        errors.append(msg)

                    if not errors:
                        try:
                            dns = None
                            dns_params = request.POST.get('dns')
                            if dns_params:
                                dns = dns_params.split(',')
                            conn.create_network(data['name'], data['forward'],
                                                gateway, netmask, dhcp,
                                                data['bridge_name'],
                                                data['openvswitch'],
                                                data['fixed'], dns,
                                                data.get('forward_dev'))
                        except libvirtError as err:
                            errors.append(err)

                    object = {
                        'errors': [str(error) for error in errors],
                        'response': {}
                    }
                    url = '/%s/network/%s/' % (host_id, data['name'])
                    return redirect_or_json(object, url, request)

        conn.close()
    except Compute.DoesNotExist, e:
        object['errors'] = e.message
示例#3
0
def storages(request, host_id):
    """
    Storage pool block
    """
    errors = []
    compute = Compute.objects.get(id=host_id)

    try:
        conn = wvmStorages(compute.hostname,
                           compute.login,
                           compute.password,
                           compute.type)
        storages = conn.get_storages_info()
        secrets = conn.get_secrets()

        if request.method == 'POST':
            if 'create' in request.POST:
                form = AddStgPool(request.POST)
                if form.is_valid():
                    data = form.cleaned_data
                    if data['name'] in storages:
                        msg = _("Pool name already use")
                        errors.append(msg)
                    if data['stg_type'] == 'rbd':
                        if not data['secret']:
                            msg = _("You need create secret for pool")
                            errors.append(msg)
                        if not data['ceph_pool'] and not data['ceph_host'] and not data['ceph_user']:
                            msg = _("You need input all fields for creating ceph pool")
                            errors.append(msg)
                    if not errors:
                        if data['stg_type'] == 'rbd':
                            conn.create_storage_ceph(data['stg_type'], data['name'],
                                                     data['ceph_pool'], data['ceph_host'],
                                                     data['ceph_user'], data['secret'])
                        else:
                            conn.create_storage(data['stg_type'], data['name'], data['source'], data['target'])
                        url = '/%s/storage/%s/' % (host_id, data['name'])
                        object = {'response': {}}
                        return redirect_or_json(object, url, request)
                else:
                    errors = [error for error in form.errors]

        conn.close()
    except libvirtError as err:
        errors.append(err)

    object = {
        'response': {
            'storages': storages,
            'secrets': secrets,
        },
        'errors': [str(error) for error in errors]
    }
    return render(object, 'storages.html', locals(), request)
示例#4
0
def networks(request, host_id):
    """
    Networks block
    """
    errors = []
    object = {}

    try:
        compute = Compute.objects.get(id=host_id)

        conn = wvmNetworks(compute.hostname,
                           compute.login,
                           compute.password,
                           compute.type)
        networks = conn.get_networks_info()

        if request.method == 'POST':
            if 'create' in request.POST:
                form = AddNetPool(request.POST)
                if form.is_valid():
                    data = form.cleaned_data
                    if data['name'] in networks:
                        msg = ("Pool name already in use")
                        errors.append(msg)
                    if data['forward'] == 'bridge' and data['bridge_name'] == '':
                        errors.append('Please enter bridge name')
                    try:
                        gateway, netmask, dhcp = network_size(data['subnet'], data['dhcp'])
                    except:
                        msg = ("Input subnet pool error")
                        errors.append(msg)

                    if not errors:
                        try:
                            dns = None
                            dns_params = request.POST.get('dns')
                            if dns_params:
                                dns = dns_params.split(',')
                            conn.create_network(data['name'], data['forward'], gateway, netmask, dhcp,
                                                data['bridge_name'], data['openvswitch'], data['fixed'], dns, data.get('forward_dev'))
                        except libvirtError as err:
                            errors.append(err)

                    object = {
                        'errors': [str(error) for error in errors],
                        'response': {}
                    }
                    url = '/%s/network/%s/' % (host_id, data['name'])
                    return redirect_or_json(object, url, request)

        conn.close()
    except Compute.DoesNotExist, e:
        object['errors'] = e.message
示例#5
0
def servers_list(request):
    """
    Servers page.
    """
    def get_hosts_status(hosts):
        """
        Function return all hosts all vds on host
        """
        all_hosts = []
        for host in hosts:
            if (connection_manager.host_is_up(host.hostname, host.login,
                                              host.password, host.type)):
                status = 1
            else:
                status = 'Unknown Error'

            all_hosts.append({
                'id': host.id,
                'name': host.name,
                'hostname': host.hostname,
                'status': status,
                'type': host.type,
                'login': host.login,
                'password': host.password
            })
        return all_hosts

    computes = Compute.objects.filter()
    hosts_info = get_hosts_status(computes)
    form = None

    if request.method == 'POST':
        if 'host_del' in request.POST:
            compute_id = request.POST.get('host_id', '')
            try:
                del_inst_on_host = Instance.objects.filter(
                    compute_id=compute_id)
                del_inst_on_host.delete()
            finally:
                del_host = Compute.objects.get(id=compute_id)
                del_host.delete()
            return HttpResponseRedirect(request.get_full_path())
        if 'host_tcp_add' in request.POST:
            form = ComputeAddTcpForm(request.POST)
            if form.is_valid():
                data = form.cleaned_data
                new_tcp_host = Compute(name=data['name'],
                                       hostname=data['hostname'],
                                       type=CONN_TCP,
                                       login=data['login'],
                                       password=data['password'])
                new_tcp_host.save()
                return HttpResponseRedirect(request.get_full_path())
        if 'host_ssh_add' in request.POST:
            form = ComputeAddSshForm(request.POST)
            if form.is_valid():
                data = form.cleaned_data
                new_ssh_host = Compute(name=data['name'],
                                       hostname=data['hostname'],
                                       type=CONN_SSH,
                                       login=data['login'])
                new_ssh_host.save()

                object = {'response': {'id': new_ssh_host.id}}
                return redirect_or_json(object, request.get_full_path(),
                                        request)
            else:
                object = {'errors': [error for error in form.errors]}
                return render(object, 'servers.html', locals(), request)

        if 'host_tls_add' in request.POST:
            form = ComputeAddTlsForm(request.POST)
            if form.is_valid():
                data = form.cleaned_data
                new_tls_host = Compute(name=data['name'],
                                       hostname=data['hostname'],
                                       type=CONN_TLS,
                                       login=data['login'],
                                       password=data['password'])
                new_tls_host.save()
                return HttpResponseRedirect(request.get_full_path())

        if 'host_edit' in request.POST:
            form = ComputeEditHostForm(request.POST)
            if form.is_valid():
                data = form.cleaned_data
                compute_edit = Compute.objects.get(id=data['host_id'])
                compute_edit.name = data['name']
                compute_edit.hostname = data['hostname']
                compute_edit.login = data['login']
                compute_edit.password = data['password']
                compute_edit.save()
                return HttpResponseRedirect(request.get_full_path())

    object = {'errors': {}, 'response': {'hosts_info': hosts_info}}

    return render(object, 'servers.html', locals(), request)
示例#6
0
def servers_list(request):
    """
    Servers page.
    """
    def get_hosts_status(hosts):
        """
        Function return all hosts all vds on host
        """
        all_hosts = []
        for host in hosts:
            if (connection_manager.host_is_up(host.hostname, host.login, host.password, host.type)):
                status = 1
            else:
                status = 'Unknown Error'

            all_hosts.append({'id': host.id,
                              'name': host.name,
                              'hostname': host.hostname,
                              'status': status,
                              'type': host.type,
                              'login': host.login,
                              'password': host.password
                              })
        return all_hosts

    computes = Compute.objects.filter()
    hosts_info = get_hosts_status(computes)
    form = None

    if request.method == 'POST':
        if 'host_del' in request.POST:
            compute_id = request.POST.get('host_id', '')
            try:
                del_inst_on_host = Instance.objects.filter(compute_id=compute_id)
                del_inst_on_host.delete()
            finally:
                del_host = Compute.objects.get(id=compute_id)
                del_host.delete()
            return HttpResponseRedirect(request.get_full_path())
        if 'host_del_by_name' in request.POST:
            compute_name = request.POST.get('host_name', '')
            try:
                del_inst_on_host = Instance.objects.filter(name=compute_name)
                del_inst_on_host.delete()
            finally:
                del_host = Compute.objects.get(name=compute_name)
                del_host.delete()
            return HttpResponseRedirect(request.get_full_path())
        if 'host_tcp_add' in request.POST:
            form = ComputeAddTcpForm(request.POST)
            if form.is_valid():
                data = form.cleaned_data
                new_tcp_host = Compute(name=data['name'],
                                       hostname=data['hostname'],
                                       type=CONN_TCP,
                                       login=data['login'],
                                       password=data['password'])
                new_tcp_host.save()
                return HttpResponseRedirect(request.get_full_path())
        if 'host_ssh_add' in request.POST:
            form = ComputeAddSshForm(request.POST)
            if form.is_valid():
                data = form.cleaned_data
                new_ssh_host = Compute(name=data['name'],
                                       hostname=data['hostname'],
                                       type=CONN_SSH,
                                       login=data['login'])
                new_ssh_host.save()

                object = {
                    'response': {
                        'id': new_ssh_host.id
                    }
                }
                return redirect_or_json(object, request.get_full_path(), request)
            else:
                object = {
                    'errors': [error for error in form.errors]
                }
                return render(object, 'servers.html', locals(), request)


        if 'host_tls_add' in request.POST:
            form = ComputeAddTlsForm(request.POST)
            if form.is_valid():
                data = form.cleaned_data
                new_tls_host = Compute(name=data['name'],
                                       hostname=data['hostname'],
                                       type=CONN_TLS,
                                       login=data['login'],
                                       password=data['password'])
                new_tls_host.save()
                return HttpResponseRedirect(request.get_full_path())

        if 'host_edit' in request.POST:
            form = ComputeEditHostForm(request.POST)
            if form.is_valid():
                data = form.cleaned_data
                compute_edit = Compute.objects.get(id=data['host_id'])
                compute_edit.name = data['name']
                compute_edit.hostname = data['hostname']
                compute_edit.login = data['login']
                compute_edit.password = data['password']
                compute_edit.save()
                return HttpResponseRedirect(request.get_full_path())

    object = {
        'errors': {},
        'response': {
            'hosts_info': hosts_info
        }
    }

    return render(object, 'servers.html', locals(), request)