k2hr3client package

Submodules

k2hr3client.acr module

K2HR3 Python Client of ACR API.

# Import modules from k2hr3client package.
from k2hr3client.token import K2hr3Token
from k2hr3client.http import K2hr3Http
from k2hr3client.acr import K2hr3Acr

iaas_project = "demo"
iaas_token = "gAAAAA..."
mytoken = K2hr3Token(iaas_project, iaas_token)

# POST a request to create a token to K2HR3 Token API.
myhttp = K2hr3Http("http://127.0.0.1:18080")
myhttp.POST(mytoken.create())
mytoken.token  # gAAAAA...

# POST a request to add member to K2HR3 ACR API.
myacr = K2hr3Acr(mytoken.token, "service")
myhttp.POST(myacr.add_member("mytenant"))

class k2hr3client.acr.K2hr3Acr(r3token: str, service: str)

Bases: K2hr3Api

Relationship with K2HR3 ACR API.

See https://k2hr3.antpick.ax/api_acr.html

add_member(tenant: str | None)

Add the members.

delete_member(tenant: str)

Delete the members.

get_available_resources(cip: str | None = None, cport: str | None = None, crole: str | None = None, ccuk: str | None = None, sport: str | None = None, srole: str | None = None, scuk: str | None = None)

Show the available resources.

property r3token: str

Return the r3token.

property service: str

Return the tenant.

show_credential_details()

Show the credential details.

k2hr3client.api module

k2hr3client - Python library for K2HR3 API.

# Import modules from k2hr3client package
from k2hr3client import version
v = version.K2hr3Version()
v.get()
from k2hr3client import http as khttp
httpreq = khttp.K2hr3Http('http://127.0.0.1:18080')

# GET the K2hr Version API.
httpreq.GET(v)
print(v.resp)

class k2hr3client.api.K2hr3Api(basepath: str, params: str | None = None, hdrs: dict | None = None, body: str | None = None, version: str = 'v1')

Bases: ABC

Base class of all K2HR3 WebAPIs.

DEFAULT_VERSION = 'v1'

property basepath: str

Return the base url path.

property body: str | None

Return the request body.

property headers: dict | None

Return the request headers.

property resp: K2hr3ApiResponse

Return the response struct.

set_response(code: int, url: str, headers: HTTPMessage, body: str | None) → None

Set the API responses in K2hr3Http class.

property urlparams: str | None

Return the url params.

property version: str

Return the version string.

class k2hr3client.api.K2hr3ApiResponse(code=None, url=None, hdrs=None, body=None)

Bases: object

K2hr3ApiResponse stores the response of K2HR3 WebAPI.

The members are set by setter methods only one time.

property body: str | None

Return the body.

property code: int

Return the status code.

property hdrs: HTTPMessage

Return the header.

property url: str

Return the request url.

class k2hr3client.api.K2hr3HTTPMethod(*values)

Bases: Enum

HTTPMethod.

CONNECT = 1

DELETE = 2

GET = 3

HEAD = 4

OPTIONS = 5

PATCH = 6

POST = 7

PUT = 8

TRACE = 9

k2hr3client.exception module

K2HR3 Python Client of Exception.

exception k2hr3client.exception.K2hr3Exception

Bases: Exception

Exception classes for K2HR3 Python Client.

k2hr3client.extdata module

k2hr3client - Python library for k2hr3 Extdata API.

# Import modules from k2hr3client package
from k2hr3client import http as khttp
httpreq = khttp.K2hr3Http('http://127.0.0.1:18080')

from k2hr3client import extdata
example = extdata.K2hr3Extdata("uripath","registerpath","ua 1.0.0")

# GET the K2hr Extdata API.
httpreq.GET(example.acquires_template())
print(example.resp)

class k2hr3client.extdata.K2hr3Extdata(extapi_name: str, register_path: str, user_agent: str)

Bases: K2hr3Api

Relationship with K2HR3 EXTDATA API.

See https://k2hr3.antpick.ax/api_extdata.html for details.

acquires_template() → None

Set a request to acquire a template.

property extapi_name: str

Return the tenant.

property register_path: str

Return the tenant.

property user_agent: str

Return the tenant.

k2hr3client.http module

k2hr3client - Python library for K2HR3 API.

# Import modules from k2hr3client package
from k2hr3client import http as khttp
httpreq = khttp.K2hr3Http('http://127.0.0.1:18080')

from k2hr3client import extdata
example = extdata.K2hr3Extdata("uripath","registerpath","ua 1.0.0")

# GET the K2hr Extdata API.
httpreq.GET(example.acquires_template())
print(example.resp)

class k2hr3client.http.K2hr3Http(baseurl: str)

Bases: object

K2hr3Http sends a http/https request to the K2hr3 WebAPI.

Most of the members are set by setter methods only one time.

DELETE(r3api: K2hr3Api) → bool

Send requests by using DELETE Method.

GET(r3api: K2hr3Api) → bool

Send requests by using GET Method.

HEAD(r3api: K2hr3Api) → bool

Send requests by using GET Method.

POST(r3api: K2hr3Api) → bool

Send requests by using POST Method.

PUT(r3api: K2hr3Api) → bool

Send requests by using PUT Method.

property baseurl: str | None

Returns the url.

property headers: dict

Return the request headers.

property url: str | None

Returns the url.

property urlparams: str | None

Returns the urlparams.

k2hr3client.list module

K2HR3 Python Client of List API.

# Import modules from k2hr3client package.
from k2hr3client.token import K2hr3Token
from k2hr3client.http import K2hr3Http
from k2hr3client.list import K2hr3List

iaas_project = "demo"
iaas_token = "gAAAAA..."
mytoken = K2hr3Token(iaas_project, iaas_token)

# POST a request to create a token to K2HR3 Token API.
myhttp = K2hr3Http("http://127.0.0.1:18080")
myhttp.POST(mytoken.create())
mytoken.token  # gAAAAA...

# GET a request to get list from K2HR3 List API.
mylist = K2hr3List(mytoken.token, "service")
myhttp.GET(mylist.get())
mylist.resp.body # {"result":true...

class k2hr3client.list.K2hr3List(r3token: str, service: str)

Bases: K2hr3Api

Relationship with K2HR3 LIST API.

See https://k2hr3.antpick.ax/api_list.html

get(expand=False)

List K2HR3’s SERVICE, RESOURCE, POLICY and ROLE in YRN form.

property r3token: str

Return the r3token.

property service: str

Return the service.

validate()

Validate the objects.

k2hr3client.policy module

K2HR3 Python Client of Policy API.

# Import modules from k2hr3client package.
from k2hr3client.token import K2hr3Token
from k2hr3client.http import K2hr3Http
from k2hr3client.policy import K2hr3Policy

iaas_project = "demo"
iaas_token = "gAAAAA..."
mytoken = K2hr3Token(iaas_project, iaas_token)

# POST a request to create a token to K2HR3 Token API.
myhttp = K2hr3Http("http://127.0.0.1:18080")
myhttp.POST(mytoken.create())
mytoken.token  # gAAAAA...

# POST request to get a K2HR3 Policy API.
mypolicy = K2hr3Policy(mytoken.token)
RESOURCE_PATH = "yrn:yahoo:::demo:resource:test_resource"
myhttp.POST(
    mypolicy.create(
        name="test_policy",
        effect="allow",
        action=['yrn:yahoo::::action:read'],
        resource=[RESOURCE_PATH],
        condition=None,
        alias=[]
        )
    )
mypolicy.resp.body # {"result":true...

class k2hr3client.policy.K2hr3Policy(r3token: str)

Bases: K2hr3Api

Relationship with K2HR3 POLICY API.

See https://k2hr3.antpick.ax/api_policy.html for details.

create(name: str, effect: str, action: List[str] | None, resource: List[str] | None = None, condition: str | None = None, alias: List[str] | None = None, policy_name: str | None = None)

Create policies.

delete(name: str, policy_name: str | None = None)

Delete policies.

get(name: str, service: str, policy_name: str | None = None)

Get policies.

property r3token: str

Return the r3token.

validate(name: str, tenant: str, resource: str, action: str, service: str | None = None, policy_name: str | None = None)

Validate policies.

k2hr3client.resource module

K2HR3 Python Client of Resource API.

# Import modules from k2hr3client package.
from k2hr3client.token import K2hr3Token
from k2hr3client.http import K2hr3Http
from k2hr3client.resource import K2hr3Resource

iaas_project = "demo"
iaas_token = "gAAAAA..."
mytoken = K2hr3Token(iaas_project, iaas_token)

# POST a request to create a token to K2HR3 Token API.
myhttp = K2hr3Http("http://127.0.0.1:18080")
myhttp.POST(mytoken.create())
mytoken.token  # gAAAAA...

# POST a request to create a K2HDKC resource.
myresource = K2hr3Resource(mytoken.token)
myhttp.POST(
    myresource.create_conf_resource(
        name="test_resource",
        data_type="string",
        resource_data="testresourcedata",
        keys={
            "cluster-name": "test-cluster",
            "chmpx-server-port": "8020",
            "chmpx-server-ctrlport": "8021",
            "chmpx-slave-ctrlport": "8031"},
        alias=[])
    )
myresource.resp.body # {"result":true...

class k2hr3client.resource.K2hr3Resource(r3token: str | None = None, roletoken: str | None = None, resource_path: str | None = None)

Bases: K2hr3Api

Relationship with K2HR3 RESOURCE API.

See https://k2hr3.antpick.ax/api_resource.html for details.

create_conf_resource(name: str, data_type: str, resource_data: str, keys: dict | None = None, alias: list | None = None)

Create the resource.

delete_with_notoken(port: str, cuk: str, role: str, data_type: str, keys: dict | None)

Delete the resource without token.

delete_with_roletoken(data_type: str, keys: dict | None)

Delete the resource with role token.

delete_with_scopedtoken(data_type: str, keys: dict | None, alias: list | None = None)

Delete the resource with scoped token.

get(expand: bool = False, service: str | None = None)

Get the resource.

get_with_roletoken(data_type: str, keys: dict | None, service: str | None = None)

Get the resource with roletoken.

static json_dumps(params)

Return the json params after deleting None data.

property r3token

Return the r3token.

property resource_path

Return the resource_path.

property roletoken

Return the roletoken.

validate(data_type: str, keys: dict | None, service: str | None = None)

Validate the resource.

validate_with_notoken(port: str, cuk: str, role: str, data_type: str, keys: dict | None, service: str | None = None)

Validate the resource without tokens.

k2hr3client.role module

K2HR3 Python Client of Role API.

# Simple CUI application to create a role.
from __future__ import (absolute_import, division, print_function,
                        unicode_literals)
import argparse
import json
import os
from pathlib import Path
import re
import sys
import urllib.parse
import urllib.request

here = os.path.dirname(__file__)
src_dir = os.path.join(here, '..')
if os.path.exists(src_dir):
    sys.path.append(src_dir)

import k2hr3client
from k2hr3client.exception import K2hr3Exception
from k2hr3client.http import K2hr3Http
from k2hr3client.token import K2hr3Token
from k2hr3client.resource import K2hr3Resource
from k2hr3client.policy import K2hr3Policy
from k2hr3client.role import K2hr3Role

_MAX_LINE_LENGTH = 1024 * 8

IDENTITY_V3_PASSWORD_AUTH_JSON_DATA = '''
{
    "auth": {
        "identity": {
            "methods": [
                "password"
            ],
            "password": {
                "user": {
                    "name": "admin",
                    "domain": {
                        "name": "Default"
                    },
                    "password": "devstacker"
                }
            } }
    }
}
'''

IDENTITY_V3_TOKEN_AUTH_JSON_DATA = '''
{
    "auth": {
        "identity": {
            "methods": [
                "token"
            ],
            "token": {
                "id": ""
            }
        },
        "scope": {
            "project": {
                "domain": {
                    "id": "default"
                },
                "name": ""
            }
        }
    }
}
'''

def get_scoped_token_id(url, user, password, project):
    # Get a scoped token id from openstack identity.
    # unscoped token-id
    # https://docs.openstack.org/api-ref/identity/v3/index.html#password-authentication-with-unscoped-authorization
    python_data = json.loads(IDENTITY_V3_PASSWORD_AUTH_JSON_DATA)
    python_data['auth']['identity']['password']['user']['name'] = user
    python_data['auth']['identity']['password']['user']['password'] = password
    headers = {
        'User-Agent': 'doc_sample',
        'Content-Type': 'application/json'
    }
    req = urllib.request.Request(url,
                                 json.dumps(python_data).encode('ascii'),
                                 headers,
                                 method="POST")
    with urllib.request.urlopen(req) as res:
        unscoped_token_id = dict(res.info()).get('X-Subject-Token')
        print('unscoped_token_id:[{}]'.format(unscoped_token_id))

    # scoped token-id
    # https://docs.openstack.org/api-ref/identity/v3/index.html?expanded=#token-authentication-with-scoped-authorization
    python_data = json.loads(IDENTITY_V3_TOKEN_AUTH_JSON_DATA)
    python_data['auth']['identity']['token']['id'] = unscoped_token_id
    python_data['auth']['scope']['project']['name'] = project
    headers = {
        'User-Agent': 'doc_sample',
        'Content-Type': 'application/json'
    }
    req = urllib.request.Request(url,
                                 json.dumps(python_data).encode('ascii'),
                                 headers,
                                 method="POST")
    with urllib.request.urlopen(req) as res:
        scoped_token_id = dict(res.info()).get('X-Subject-Token')
        print('scoped_token_id:[{}]'.format(scoped_token_id))
        return scoped_token_id


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='k2hr3 token api example')
    parser.add_argument(
        '--url',
        dest='url',
        default='http://127.0.0.1/identity/v3/auth/tokens',
        help='identity api url. ex) http://127.0.0.1/identity/v3/auth/tokens')  # noqa
    parser.add_argument('--user',
                        dest='user',
                        default='demo',
                        help='openstack user')
    parser.add_argument('--password',
                        dest='password',
                        default='password',
                        help='openstack user password')
    parser.add_argument('--project',
                        dest='project',
                        default='demo',
                        help='openstack project')
    parser.add_argument('--k2hr3_url',
                        dest='k2hr3_url',
                        default='http://localhost:18080',
                        help='k2hr3 api url')
    parser.add_argument('--resource',
                        dest='resource',
                        default='doc_sample',
                        help='resource name')
    parser.add_argument('--policy',
                        dest='policy',
                        default='doc_sample',
                        help='policy name')
    parser.add_argument('--role',
                        dest='role',
                        default='doc_sample',
                        help='k2hr3 rolename')

    args = parser.parse_args()

    # 1. Gets a openstack token id from openstack identity server
    openstack_token = get_scoped_token_id(args.url, args.user, args.password,
                                          args.project)

    # 2. Gets a k2hr3 token from the openstack token
    k2hr3_token = K2hr3Token(args.project, openstack_token)
    http = K2hr3Http(args.k2hr3_url)
    http.POST(k2hr3_token.create())

    # 3. Makes a new k2hr3 resource
    k2hr3_resource = K2hr3Resource(k2hr3_token.token)
    resource_data = args.resource

    http.POST(
        k2hr3_resource.create_conf_resource(
            name=args.resource,
            data_type='string',
            resource_data=resource_data,
            keys={
                "doc_sample": args.resource
            },
            alias=[]
        )
    )

    # 4. Makes a new k2hr3 policy for the resource
    k2hr3_policy = K2hr3Policy(k2hr3_token.token)
    MY_RESOURCE_PATH = "yrn:yahoo:::{}:resource:{}/doc_sample".format(
        args.project, args.resource)
    http.POST(
        k2hr3_policy.create(
            name=args.policy,
            effect='allow',
            action=['yrn:yahoo::::action:read'],
            resource=[MY_RESOURCE_PATH],
            condition=None,
            alias=[]
        )
    )

    # 5. Makes a new k2hr3 role for the policy
    POLICY_PATH = "yrn:yahoo:::{}:policy:{}".format(args.project, args.policy)
    k2hr3_role = K2hr3Role(k2hr3_token.token)
    http.POST(
        k2hr3_role.create(
            name=args.role,
            policies=[POLICY_PATH],
            alias=[]
        )
    )

    print(slave_role.resp.body)
    sys.exit(0)

class k2hr3client.role.K2hr3Role(r3token: str, token_type=K2hr3TokenType.SCOPED_TOKEN)

Bases: K2hr3Api

Relationship with K2HR3 ROLE API.

See https://k2hr3.antpick.ax/api_role.html

add_member(name: str, host: str, clear_hostname: bool, clear_ips: str, role_name: str | None = None)

Add a member to the role.

add_member_with_roletoken(name: str, port: str, cuk: str, extra: str, tag: str, inboundip: str, outboundip: str, role_name: str | None = None)

Add members to the role without roletoken.

add_members(name: str, hosts: str, clear_hostname: bool, clear_ips: str, role_name: str | None = None)

Add members to the role.

create(name: str, policies: List[str], alias: List[str], role_name: str | None = None)

Create tokens.

delete(name: str, role_name: str | None = None)

Delete role.

delete_member(name: str, host: str, port: str, cuk: str, role_name: str | None = None)

Delete host.

delete_member_wo_roletoken(cuk: str)

Delete host without roletoken.

delete_roletoken(name: str, port: str, cuk: str, role_name: str | None = None)

Delete roletoken.

delete_roletoken_with_string(role_token_string: str)

Delete roletoken without role.

get(name: str, expand: bool = True, role_name: str | None = None)

Show role details.

get_token_list(name: str, expand: bool = True, role_name: str | None = None)

Show token list.

property r3token: str

Return the r3token.

validate_role(name: str, role_name: str | None = None)

Validate role.

class k2hr3client.role.K2hr3RoleHost(host: str, port: str, cuk: str, extra: str, tag: str, inboundip: str, outboundip: str)

Bases: object

Represent a host of a role.

NOTE(hiwakaba): This class exists only for backward compatibility.

class k2hr3client.role.K2hr3RoleHostList

Bases: object

Represent a list of hosts of a role.

NOTE(hiwakaba): This class exists only for backward compatibility.

add_host(host)

Add hosts to the list.

class k2hr3client.role.K2hr3TokenType(*values)

Bases: Enum

Represent a type of token.

NO_TOKEN = 3

ROLE_TOKEN = 2

SCOPED_TOKEN = 1

k2hr3client.service module

K2HR3 Python Client of Service API.

# Import modules from k2hr3client package.
from k2hr3client.token import K2hr3Token
from k2hr3client.http import K2hr3Http
from k2hr3client.service import K2hr3Service

iaas_project = "demo"
iaas_token = "gAAAAA..."
mytoken = K2hr3Token(iaas_project, iaas_token)

# POST a request to create a token to K2HR3 Token API.
myhttp = K2hr3Http("http://127.0.0.1:18080")
myhttp.POST(mytoken.create())
mytoken.token  # gAAAAA...

# POST a request to create a service to K2HR3 Service API.
myservice = K2hr3Service(mytoken.token, "test_service")
myhttp.POST(
    myservice.create(
        verify = "http://example.com/verify_url.php"
    )
)
myservice.resp.body # {"result":true...

class k2hr3client.service.K2hr3Service(r3token: str, service_name: str)

Bases: K2hr3Api

Relationship with K2HR3 SERVICE API.

See https://k2hr3.antpick.ax/api_service.html for details.

add_member(tenant: str, clear_tenant: bool)

Add members to services.

create(verify_url: str)

Create services.

delete()

Delete services.

delete_tenant(tenant: str)

Delete tenants.

get()

Get services.

modify(verify_url: str)

Modify services.

property r3token: str

Return the r3token.

validate(tenant: str | None = None)

Validate services.

k2hr3client.tenant module

K2HR3 Python Client of Tenant API.

# Import modules from k2hr3client package.
from k2hr3client.token import K2hr3Token
from k2hr3client.http import K2hr3Http
from k2hr3client.tenant import K2hr3Tenant

iaas_project = "demo"
iaas_token = "gAAAAA..."
mytoken = K2hr3Token(iaas_project, iaas_token)

# POST a request to create a token to K2HR3 Token API.
myhttp = K2hr3Http("http://127.0.0.1:18080")
myhttp.POST(mytoken.create())
mytoken.token  # gAAAAA...

# POST a request to create a tenant to K2HR3 Tenant API.
mytenant = K2hr3Tenant(mytoken.token)
myhttp.POST(
    mytenant.create(
        tenant_name = "test_tenant",
        users = ["demo"],
        desc = "test_tenant description",
        display = "test tenant display"
    )
)
mytenant.resp.body # {"result":true...

class k2hr3client.tenant.K2hr3Tenant(r3token: str)

Bases: K2hr3Api

Relationship with K2HR3 TENANT API.

See https://k2hr3.antpick.ax/api_tenant.html for details.

create(tenant_name: str, users: List[str] | None, desc: str | None, display: str | None)

Create a new K2HR3 cluster Local Tenant(TENANT).

delete(tenant_name: str, tenant_id: int)

Completely delete the Local Tenant(TENANT).

delete_user(tenant_name: str, tenant_id: int)

Make the USER unavailable to the K2HR3 cluster Local Tenant(TENANT).

get(tenant_name: str)

Get the K2HR3 cluster Local Tenant(TENANT) information.

get_tenant_list(expand: bool = False)

List the K2HR3 cluster Local Tenant(TENANT).

modify(tenant_name: str, tenant_id: int, users: List[str] | None, desc: str | None, display: str | None)

Update the K2HR3 cluster Local Tenant(TENANT).

property r3token: str

Return the r3token.

validate(tenant_name: str)

Check the existence of the K2HR3 cluster Local Tenant(TENANT).

k2hr3client.token module

K2HR3 Python Client of Token API.

# Simple CUI application to get registerpath for a k2hr3 role.
from __future__ import (absolute_import, division, print_function,
                        unicode_literals)
import argparse
import os
import sys
import json
import urllib.parse
import urllib.request

here = os.path.dirname(__file__)
src_dir = os.path.join(here, '..')
if os.path.exists(src_dir):
    sys.path.append(src_dir)

from k2hr3client.http import K2hr3Http
from k2hr3client.token import K2hr3Token
from k2hr3client.token import K2hr3RoleToken
from k2hr3client.token import K2hr3RoleTokenList

IDENTITY_V3_PASSWORD_AUTH_JSON_DATA = '''
{
    "auth": {
        "identity": {
            "methods": [
                "password"
            ],
            "password": {
                "user": {
                    "name": "admin",
                    "domain": {
                        "name": "Default"
                    },
                    "password": "devstacker"
                }
            } }
    }
}
'''

IDENTITY_V3_TOKEN_AUTH_JSON_DATA = '''
{
    "auth": {
        "identity": {
            "methods": [
                "token"
            ],
            "token": {
                "id": ""
            }
        },
        "scope": {
            "project": {
                "domain": {
                    "id": "default"
                },
                "name": ""
            }
        }
    }
}
'''

def get_scoped_token_id(url, user, password, project):
    # Get a scoped token id from openstack identity.
    # unscoped token-id
    # https://docs.openstack.org/api-ref/identity/v3/index.html#password-authentication-with-unscoped-authorization
    python_data = json.loads(IDENTITY_V3_PASSWORD_AUTH_JSON_DATA)
    python_data['auth']['identity']['password']['user']['name'] = user
    python_data['auth']['identity']['password']['user']['password'] = password  # noqa
    headers = {
        'User-Agent': 'doc_sample',
        'Content-Type': 'application/json'
    }
    req = urllib.request.Request(url,
                                 json.dumps(python_data).encode('ascii'),
                                 headers,
                                 method="POST")
    with urllib.request.urlopen(req) as res:
        unscoped_token_id = dict(res.info()).get('X-Subject-Token')
        # print('unscoped_token_id:[{}]'.format(unscoped_token_id))

    # scoped token-id
    # https://docs.openstack.org/api-ref/identity/v3/index.html?expanded=#token-authentication-with-scoped-authorization
    python_data = json.loads(IDENTITY_V3_TOKEN_AUTH_JSON_DATA)
    python_data['auth']['identity']['token']['id'] = unscoped_token_id
    python_data['auth']['scope']['project']['name'] = project
    headers = {
        'User-Agent': 'doc_sample',
        'Content-Type': 'application/json'
    }
    req = urllib.request.Request(url,
                                 json.dumps(python_data).encode('ascii'),
                                 headers,
                                 method="POST")
    with urllib.request.urlopen(req) as res:
        scoped_token_id = dict(res.info()).get('X-Subject-Token')
        # print('scoped_token_id:[{}]'.format(scoped_token_id))
        return scoped_token_id


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='k2hr3 token api example')
    parser.add_argument(
        '--url',
        dest='url',
        default='http://127.0.0.1/identity/v3/auth/tokens',
        help='identity api url. ex) http://127.0.0.1/identity/v3/auth/tokens')  # noqa
    parser.add_argument('--user',
                        dest='user',
                        default='demo',
                        help='openstack user')
    parser.add_argument('--password',
                        dest='password',
                        default='password',
                        help='openstack user password')
    parser.add_argument('--project',
                        dest='project',
                        default='demo',
                        help='openstack project')
    parser.add_argument('--k2hr3_url',
                        dest='k2hr3_url',
                        default='http://localhost:18080',
                        help='k2hr3 api url')
    parser.add_argument('--role',
                        dest='role',
                        default='doc_sample',
                        help='k2hr3 rolename')
    args = parser.parse_args()

    # 1. Gets a openstack token id from openstack identity server
    openstack_token = get_scoped_token_id(args.url, args.user, args.password,  # noqa
                                          args.project)

    # 2. Gets a k2hr3 token from the openstack token
    k2hr3_token = K2hr3Token(args.project, openstack_token)
    http = K2hr3Http(args.k2hr3_url)
    http.POST(k2hr3_token.create())

    # 3. Gets a k2hr3 role token from the k2hr3 token
    k2hr3_role_token = K2hr3RoleToken(k2hr3_token.token,
                                      role=args.role,
                                      expire=0)
    http.GET(k2hr3_role_token)
    roletoken = k2hr3_role_token.token
    print("roletoken {}".format(roletoken))

    # 4. Gets a k2hr3 role token list from the k2hr3 token
    k2hr3_role_token_list = K2hr3RoleTokenList(k2hr3_token.token,
                                               role=args.role,
                                               expand=True)
    http.GET(k2hr3_role_token_list)

    # 4. Gets the registerpath of the k2hr3 role token
    registerpath = k2hr3_role_token_list.registerpath(roletoken)
    print("{}".format(registerpath))
    sys.exit(0)

class k2hr3client.token.K2hr3AuthType(*values)

Bases: Enum

Represent the type of authentication.

CREDENTIAL = 1

TOKEN = 2

class k2hr3client.token.K2hr3RoleToken(r3token, role, expire)

Bases: K2hr3Api

Represent K2hr3 ROLE TOKEN API.

See https://k2hr3.antpick.ax/api_role.html for details.

property expire

Return the expire.

property r3token

Return the r3token.

property role

Return the role.

property token

Return k2hr3 token.

class k2hr3client.token.K2hr3RoleTokenList(r3token, role, expand)

Bases: K2hr3Api

Represent K2hr3 ROLE TOKEN LIST API.

See https://k2hr3.antpick.ax/api_role.html for details.

property expand

Return the expand.

property r3token

Return the r3token.

registerpath(roletoken)

Set the registerpath.

property role

Return the role.

class k2hr3client.token.K2hr3Token(iaas_project, iaas_token, auth_type=K2hr3AuthType.TOKEN, version='v1')

Bases: K2hr3Api

Relationship with K2hr3 TOKEN API.

See https://k2hr3.antpick.ax/api_token.html for details.

create(user=None, password=None)

Create tokens.

static get_openstack_token(identity_url, user, password, project)

Get the openstack token.

property iaas_project

Return the k2hr3 tenant.

property iaas_token

Return the openstack token.

show()

Show details of tokens.

property token

Return k2hr3 token.

validate()

Validate tokens.

k2hr3client.userdata module

K2HR3 Python Client of Userdata API.

# Import modules from k2hr3client package.
from k2hr3client.token import K2hr3Token
from k2hr3client.http import K2hr3Http
from k2hr3client.userdata import K2hr3Userdata

# GET a userdatascript from K2HR3 Userdata API.
userdata_path = "testpath"
myuserdata = K2hr3Userdata(userdata_path)
myhttp.GET(
    myuserdata.provides_userdata_script()
)
myuserdata.resp.body # {"result":true...

class k2hr3client.userdata.K2hr3Userdata(userdatapath: str)

Bases: K2hr3Api

Relationship with K2HR3 USERDATA API.

See https://k2hr3.antpick.ax/api_userdata.html for details.

provides_userdata_script()

Get userdata.

property userdatapath: str

Return the tenant.

k2hr3client.version module

K2HR3 Python Client of Version API.

# Import modules from k2hr3client package
from k2hr3client import version
v = version.K2hr3Version()
v.get()
from k2hr3client import http as khttp
httpreq = khttp.K2hr3Http('http://127.0.0.1:18080')

# GET the K2hr Version API.
httpreq.GET(v)
print(v.resp)

class k2hr3client.version.K2hr3Version(version='')

Bases: K2hr3Api

Relationship with K2HR3 VERSION API.

See https://k2hr3.antpick.ax/api_version.html for details.

get()

Get the version.

Module contents

K2HR3 Python Client of Token API.

k2hr3client.get_version() → str

Return a version of the package.

Returns:

version

Return type:

str