Example #1
0
    def __init__(self,
                 username,
                 password,
                 tenant,
                 auth_url,
                 heat_url,
                 region=None):
        self.username = username
        self.password = password
        self.tenant = tenant
        self.auth_url = auth_url
        self.heat_url = heat_url
        self.region = region
        self.stack_list = []

        keystone = keystone_client(username=self.username,
                                   password=self.password,
                                   tenant_name=self.tenant,
                                   auth_url=self.auth_url)
        self.token = keystone.auth_token
        self.heat = heat_client('1',
                                endpoint=self.heat_url,
                                region_name=self.region,
                                token=self.token,
                                insecure=True)
Example #2
0
    def __init__(self, username, password, auth_url):
        self.username = username
        self.password = password
        self.auth_url = auth_url

        self.config = {}
        self.users = []
        self.tenant = None
        self.network = None
        self.router = None

        self.keystone = keystone_client(
            username=username,
            password=password,
            tenant_name=username,
            auth_url=auth_url
        )
        self.neutron = neutron_client(
            username=username,
            password=password,
            tenant_name=username,
            auth_url=auth_url
        )
        self.nova = nova_client.Client(
            username=username,
            api_key=password,
            project_id=username,
            auth_url=auth_url
        )
Example #3
0
    def __init__(self, username, password, auth_url):
        self.keystone = keystone_client(
            username=username,
            password=password,
            tenant_name=username,
            auth_url=auth_url)

        self.endpoints = self.keystone.service_catalog.get_endpoints()
        self.token = self.keystone.auth_ref['token']['id']

        self.glance = glance_client(
            endpoint=self.endpoints['image'][0]['internalURL'],
            token=self.token)

        self.neutron = neutron_client(
            username=username,
            password=password,
            tenant_name=username,
            auth_url=auth_url,
            endpoint_type='internalURL')

        self.nova = nova_client.Client(
            username=username,
            api_key=password,
            project_id=username,
            auth_url=auth_url,
            endpoint_type='internalURL')

        self.images = []
        self.network = {}
        self.router = {}
        self.users = {}
        self.admin = {'username': username, 'password': password}
Example #4
0
def admin(request, optype):
    """admin 管理路径"""
    username = request.session.get("username", None)
    password = request.session.get("password", None)
    tenant_name = request.session.get("tenant_name", None)

    try:
        keystone = keystone_client(
            username=username,
            password=password,
            tenant_name=tenant_name,
            auth_url=AUTH_URL_V2)
        keystone.users.list()
    except Exception as exc:
        print exc.message
        django_messages.add_message(
            request, 50, exc.message, extra_tags="danger")
        return redirect(
            reverse("dashboard_auth:login") +
            "?redirect=" + request.build_absolute_uri())
    # django_messages.add_message(request, 50, "hello", extra_tags="success")
    # django_messages.add_message(request, 50, "hello1", extra_tags="info")
    # django_messages.add_message(request, 50, "hello2", extra_tags="danger")
    # django_messages.add_message(request, 50, "hello2", extra_tags="warning")
    return route_to(
        optype, request, "admin/overview.html", {
            "username": username,
            "tenant_name": tenant_name,
            "keystone_client": keystone,
        })
 def __init__(self, username, tenant, password, auth_url, base_url):
     self.tenant = tenant
     self.fusion_url = ('{}/v1/{}'.format(base_url, tenant))
     keystone = keystone_client(username=username, password=password,
                                tenant_name=tenant, auth_url=auth_url)
     self.token = keystone.auth_token
     self.headers = {'x-auth-user': username,
                     'x-auth-token': self.token,
                     'content-type': 'application/json',
                     'accept': 'application/json'}
Example #6
0
def time_stack_list(username, password, tenant, auth_url, heat_url, region,
                    statsd_server):
    keystone = keystone_client(username=username, password=password,
                               tenant_name=tenant, auth_url=auth_url)
    token = keystone.auth_token
    heat = heat_client('1', endpoint=heat_url, region_name=region, token=token)
    statsd = StatsClient(host=statsd_server)

    with statsd.timer('uptime.{}'.format(region)):
        list(heat.stacks.list())
Example #7
0
 def __init__(self, username, tenant, password, auth_url, base_url):
     self.tenant = tenant
     self.fusion_url = ('{}/v1/{}'.format(base_url, tenant))
     keystone = keystone_client(username=username,
                                password=password,
                                tenant_name=tenant,
                                auth_url=auth_url)
     self.token = keystone.auth_token
     self.headers = {
         'x-auth-user': username,
         'x-auth-token': self.token,
         'content-type': 'application/json',
         'accept': 'application/json'
     }
Example #8
0
def build_info(bot, trigger):
    '''Display build-info for a heat endpoint'''
    username = bot.config.heat.username
    password = bot.config.heat.password
    tenant_name = bot.config.heat.tenant_name
    auth_url = bot.config.heat.auth_url
    endpoint_input = trigger.group(2)
    regions = ['dfw', 'iad', 'ord', 'lon', 'syd', 'hkg']

    if endpoint_input is None:
        bot.say("Please give me an endpoint to get build-info from. See "
                ".heat-endpoints for a list.")
        return
    elif endpoint_input == 'all':
        endpoints_list = [endpoint for endpoint in ENDPOINTS]
    elif endpoint_input == 'active':
        endpoints_list = regions
    elif endpoint_input == 'inactive':
        endpoints_list = ['inactive.' + region for region in regions]
    elif endpoint_input in ENDPOINTS:
        endpoints_list = [endpoint_input]
    else:
        bot.say("{} isn't an endpoint name I recognize. See a list at "
                ".heat-endpoints".format(endpoint_input))
        return

    keystone = keystone_client(username=username,
                               password=password,
                               tenant_name=tenant_name,
                               auth_url=auth_url)
    token = keystone.auth_token

    for endpoint_label in sorted(endpoints_list):
        full_endpoint = 'https://{}/v1/{}'.format(ENDPOINTS[endpoint_label],
                                                  bot.config.heat.tenant_name)
        heat = heat_client('1',
                           endpoint=full_endpoint,
                           insecure=True,
                           token=token)

        build_info = heat.build_info.build_info()
        api_revision = build_info['api']['revision']
        engine_revision = build_info['engine']['revision']
        if 'fusion-api' in build_info:
            fusion_revision = build_info['fusion-api']['revision']
        else:
            fusion_revision = 'None'

        bot.say('{}: api: {}  engine: {}  fusion: {}'.format(
            endpoint_label, api_revision, engine_revision, fusion_revision))
Example #9
0
def build_info(bot, trigger):
    '''Display build-info for a heat endpoint'''
    username = bot.config.heat.username
    password = bot.config.heat.password
    tenant_name = bot.config.heat.tenant_name
    auth_url = bot.config.heat.auth_url
    endpoint_label = trigger.group(2)

    if endpoint_label is None:
        bot.say("Please give me an endpoint to get build-info from. See "
                ".heat-endpoints for a list.")
        return

    if endpoint_label not in ENDPOINTS:
        bot.say("{} isn't an endpoint name I recognize. See a list at "
                ".heat-endpoints".format(endpoint_label))
        return

    keystone = keystone_client(username=username,
                               password=password,
                               tenant_name=tenant_name,
                               auth_url=auth_url)
    token = keystone.auth_token
    full_endpoint = 'https://{}/v1/{}'.format(ENDPOINTS[endpoint_label],
                                              bot.config.heat.tenant_name)
    heat = heat_client('1', endpoint=full_endpoint, insecure=True, token=token)

    build_info = heat.build_info.build_info()
    api_revision = build_info['api']['revision']
    engine_revision = build_info['engine']['revision']
    if 'fusion-api' in build_info:
        fusion_revision = build_info['fusion-api']['revision']
    else:
        fusion_revision = 'None'

    bot.say('api: {}  engine: {}  fusion: {}'.format(api_revision,
                                                     engine_revision,
                                                     fusion_revision))
def main():
    parser = argparse.ArgumentParser(description='Test a heat endpoint')
    parser.add_argument('-c',
                        '--config',
                        help='Path to config file',
                        default='/etc/heat-monitoring/heat_check.cfg')
    parser.add_argument('-e',
                        '--env',
                        help='Environment settings to get from '
                        'config')
    parser.add_argument('-u', '--user', help='Username')
    parser.add_argument('-p', '--password', help='Password')
    parser.add_argument('-t', '--tenant', help='Tenant name')
    parser.add_argument(
        '-a',
        '--auth_url',
        help='Authentication URL',
        default='https://identity.api.rackspacecloud.com/v2.0/')
    parser.add_argument('-U', '--heat_url', help='URL for Heat service')
    parser.add_argument('-r', '--region', help='Region for service catalog')
    parser.add_argument(
        '-T',
        '--template',
        choices=['wp_single', 'php_app_multi', 'django_clouddb'],
        default='wp_single',
        help='Template for stack preview')

    group = parser.add_mutually_exclusive_group(required=True)
    group.add_argument('-b',
                       '--basic',
                       action='store_false',
                       help='Runs '
                       'build_info, stack_list, and stack_show times')
    group.add_argument('-P',
                       '--preview',
                       action='store_true',
                       help='Runs '
                       'stack preview times for three templates')

    args = parser.parse_args()
    config_file = args.config
    section = args.env

    config = ConfigParser.ConfigParser()
    if os.path.exists(config_file):
        config.read(config_file)

    username = args.user if args.user else config.get(section, 'username')
    password = args.password if args.password else config.get(
        section, 'password')
    tenant_name = args.tenant if args.tenant else config.get(section, 'tenant')
    auth_url = args.auth_url if args.auth_url else config.get(
        section, 'auth_url')
    heat_url = args.heat_url if args.heat_url else config.get(
        section, 'heat_url')
    region = args.region if args.region else config.get(section, 'region')

    keystone = keystone_client(username=username,
                               password=password,
                               tenant_name=tenant_name,
                               auth_url=auth_url)
    token = keystone.auth_token
    heat = heat_client('1', endpoint=heat_url, region_name=region, token=token)

    check = HeatCheck(username, password, tenant_name, auth_url, heat_url,
                      region)

    if args.preview:
        preview_templates = {
            'wp_single':
            'https://raw.githubusercontent.com/rackspace-orchestration-templates/wordpress-single/master/wordpress-single.yaml',
            'php_app_multi':
            'https://raw.githubusercontent.com/rackspace-orchestration-templates/php-app-multi/master/php-app-multi.yaml',
            'django_clouddb':
            'https://raw.githubusercontent.com/rackspace-orchestration-templates/django-clouddb/master/django-multi.yaml'
        }

        template = args.template
        url = preview_templates[template]

        if template == 'django_clouddb':
            preview_time = check.stack_preview_time(
                url, parameters={'datastore_version': '5.1'})
        else:
            preview_time = check.stack_preview_time(url)

        print('metric preview_{} float {}'.format(template, preview_time))
    else:
        bi_time = check.build_info_time()
        sl_time = check.stack_list_time()
        ss_time = check.stack_show_time()

        print('metric build_info float {}'.format(bi_time))
        print('metric stack_list float {}'.format(sl_time))
        print('metric stack_show float {}'.format(ss_time))
Example #11
0
def login(request):
    """login"""
    if request.method == "POST":
        input_name = request.POST.get("username", None)
        input_password = request.POST.get("password", None)
        redirect_url = request.GET.get("redirect", None)

        input_len = len(input_name.split('@'))
        if input_len == 2:
            # 1 普通用户
            username, groupname = input_name.split('@')
            # print username, groupname
            # 1.1检查组
            group1 = check_group(groupname)
            if group1 is None:
                django_messages.add_message(
                    request,
                    50,
                    '@%s,%s is not exist or MultiGroupExist!' %
                    (groupname, groupname),
                    extra_tags="danger")
                return render(request, "auth/login.html", {
                    'username': input_name,
                    'redirect': redirect_url,
                    })
            # 1.2检查用户密码
            user1 = check_user(username, group1.id)
            if user1 is None:
                django_messages.add_message(
                    request,
                    50,
                    '%s@%s, username %s is not exist in %s or MultiUserExist!'
                    % (username, groupname, username, groupname),
                    extra_tags="danger")
                return render(request, "auth/login.html", {
                    'username': input_name,
                    'redirect': redirect_url,
                    })
            if user1.check_password(input_password) is True:
                request.session['username'] = username
                request.session['password'] = input_password
                request.session['groupname'] = groupname
                request.session['groupid'] = group1.id
                request.session['tenantid'] = group1.tenantid
                request.session['permission'] = '3'
                # 1.3 进入用户管理界面
                return redirect(reverse("project", args=("overview",)))
            else:
                django_messages.add_message(
                    request,
                    50,
                    'Invalid password',
                    extra_tags="danger")
                return render(request, "auth/login.html", {
                    'username': input_name,
                    'redirect': redirect_url,
                    })

        elif input_len == 1:
            # 2 管理员用户
            # 使用keystone的用户认证和管理
            try:
                # 采取管理员用户名和project(tenant)名相同的模式
                # 对于admin用户必须存在相应的admin tenant
                tenant_name = input_name

                keystone_client_1 = keystone_client(
                    username=input_name,
                    password=input_password,
                    tenant_name=tenant_name,
                    auth_url=AUTH_URL_V2)
                request.session['username'] = input_name
                request.session['tenant_name'] = tenant_name
                request.session['password'] = input_password
            except (keystone_exceptions.Unauthorized,
                    keystone_exceptions.Forbidden,
                    keystone_exceptions.NotFound) as exc:
                print exc.message
                msg = 'Invalid user name or password.'
                django_messages.add_message(
                    request,
                    50,
                    msg,
                    extra_tags="danger")
                return render(request, "auth/login.html", {
                    'username': input_name,
                    'redirect': redirect_url,
                    })
            except (keystone_exceptions.ClientException,
                    keystone_exceptions.AuthorizationFailure) as exc:
                print exc.message
                django_messages.add_message(
                    request,
                    50,
                    'Invalid user name or password',
                    extra_tags="danger")
                return render(request, "auth/login.html", {
                    'username': input_name,
                    'redirect': redirect_url,
                    })
            if input_name == "admin":
                # 2.1 进入admin管理界面
                request.session['permission'] = '1'
                return redirect(reverse("admin", args=("overview",)))
            else:
                # 2.2 进入普通管理员界面
                request.session['permission'] = '2'
                return redirect(reverse("project", args=("overview",)))
        else:
            # error
            print "input_len unexception!"
            pass
        #try:
        #    keystone_client_1 = \
        #        keystone_client(username=username,
        #            password=password,
        #            tenant_name=tenant_name,
        #            auth_url=AUTH_URL_V2)
        #result = authenticate(username=username, password=password)
        #if result["result"] is True:
        #    request.session['username'] = username
        #    request.session['password'] = password
        #    request.session['auth_ref'] = result['client'].auth_ref
        #    if redirect_url is None or redirect_url == "":
        #        return redirect(reverse("project", args=("overview",)))
        #    else:
        #        return redirect(redirect_url)
        #else:
        #    print result["message"]
        #    return render(request, "auth/login.html", {
        #        'message': result["message"],
        #        'username': username,
        #        'redirect': redirect_url,
        #    })
    username = request.session.get("username", "")
    return render(request, "auth/login.html", {'username': username})