OpenResty Edge™ Python SDK Manual

# Edge2Client

client = Edge2Client(host, username, password, api_token=None)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

# or

client = Edge2Client('http://127.0.0.1:8080', None, None, 'api_token')

# login

ok = login()

Returns True if login success else False.

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
ok = client.login()

# use_app

ok = use_app(app_id)

Returns True if success else False.

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

client.use_app(10)

# new_app

app_id = new_app(domains, label)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com', cluster_groups = [1])

# put_app

ok = put_app(domains, label)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

ok = client.put_app(app_id, domains = ['*.foo.com'], label = 'foo.com')

# get_app

data = get_app()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

data = client.get_app()

# put_app_config

ok = put_app_config(limiter)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

ok = client.put_app_config(app_id, {'max_uri_args': 120, 'check_post_args_type': False}, True)

# get_app_config

data = get_app_config(app_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

data = client.get_app_config(app_id)

# del_app

ok = del_app(app_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

ok = client.del_app(app_id)

# search_app

data = search_app(app_domain)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

data = client.search_app(app_domain = 'orig.foo.com')

# search_http_app_by_keyword

data = search_http_app_by_keyword(keyword, page, pagesize)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

data = client.search_http_app_by_keyword('orig.foo.com')
data = client.search_http_app_by_keyword('orig.foo.com', 1, 50)
data = client.search_http_app_by_keyword('origin')

# search_upstream_by_ip

data = search_upstream_by_ip(ip, page, pagesize)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

data = client.search_upstream_by_ip('1.1.1.1')

# search_k8s_upstream_by_ip

data = search_k8s_upstream_by_ip(ip, page, pagesize)

# Example

from edge2client import Edge2Client
client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()
data = client.search_k8s_upstream_by_ip('1.1.1.1')

# search_upstream_by_name

data = search_upstream_by_name(name, page, pagesize)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

data = client.search_upstream_by_name('test')

# search_k8s_upstream_by_name

data = search_k8s_upstream_by_name(name, page, pagesize)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

data = client.search_k8s_upstream_by_name('test')

# search_k8s_upstream

data = search_k8s_upstream(namespace, service, port, page, pagesize, type_list=['k8s_http', 'k8s_global']):

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

data = client.search_k8s_upstream(port = 80, service = "test-hello", namespace = "default")

# search_k8s_upstream_history

data = search_k8s_upstream_history( page, pagesize, start_time, end_time):

# Example

from edge2client import Edge2Client
client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()
data = client.search_k8s_upstream_history(1, 10)

# get_all_apps

data = get_all_apps(detail)

the return data will be list if detail is False, and will be dict if detail is True.

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

apps = client.get_all_apps()

apps = client.get_all_apps(detail = True)

# new_upstream

app_id = new_upstream(**kwargs)

Description of dict **kwargs:

# servers

Description of array servers in **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

up_id = client.new_upstream(name = 'origin-upstream',
                            servers = [
                                {'ip': '172.22.31.1', 'port': 80},
                                {'ip': '172.22.31.2', 'port': 80, 'weight': 2}
                            ])

# put_upstream

ok = put_upstream(**kwargs)

Description of dict **kwargs:

# servers

Description of array servers in **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

up_id = client.new_upstream(name = 'origin-upstream',
                            servers = [
                                {'domain': 'a.com', 'port': 80},
                                {'ip': '172.22.31.2', 'port': 80, 'weight': 2}
                            ])

ok = client.put_upstream(up_id, name = 'origin-upstream',
                    servers = [
                        {'domain': 'test.com', 'port': 8080},
                        {'ip': '172.22.31.2', 'port': 8080, 'weight': 1}
                    ],
                    health_checker = {
                        'type': 'http',
                        'http_req_uri': '/status',
                        'http_req_host': 'test.com',
                        'interval': 3,
                        'interval_unit': 'sec',
                        'timeout': 1,
                        'fall': 3,
                        'rise': 2,
                        'valid_statuses': [200, 302],
                        'report_interval': 3,
                        'report_interval_unit': 'min'
                    })

# get_upstream

data = get_upstream(up_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

up_id = client.new_upstream(name = 'origin-upstream',
                            servers = [
                                {'ip': '172.22.31.1', 'port': 80},
                                {'ip': '172.22.31.2', 'port': 80, 'weight': 2}
                            ])

data = client.get_upstream(up_id)

# del-upstream

ok = del_upstream(up_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

up_id = client.new_upstream(name = 'origin-upstream',
                            servers = [
                                {'ip': '172.22.31.1', 'port': 80},
                                {'ip': '172.22.31.2', 'port': 80, 'weight': 2}
                            ])

ok = client.del_upstream(up_id)

# get_all_upstreams

upstreams = client.get_all_upstreams()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

up_id = client.new_upstream(name = 'origin-upstream',
                            servers = [
                                {'ip': '172.22.31.1', 'port': 80},
                                {'ip': '172.22.31.2', 'port': 80, 'weight': 2}
                            ])

upstreams = client.get_all_upstreams(up_id)

# new_k8s_upstream

k8s_up_id = new_k8s_upstream(**kwargs)

Description of dict **kwargs:

# k8s_services

Description of array k8s_services in **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

k8s_up_id = client.new_k8s_upstream(name = 'k8s-upstream',
                            k8s_services = [
                                {
                                    'k8s' : 1,
                                    'k8s_namespace' : 'default',
                                    'k8s_service' : 'foo',
                                    'k8s_service_port' : 80,
                                }
                            ])

# copy_upstream_to_k8s_upstream

k8s_up_id = copy_upstream_to_k8s_upstream(up_id, k8s_services, rules)

# k8s_services

Description of array k8s_services in **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

up_id = client.new_upstream(name = 'origin-upstream',
                            servers = [
                                {'ip': '172.22.31.1', 'port': 80},
                                {'ip': '172.22.31.2', 'port': 80, 'weight': 2}
                            ])


k8s_up_id = client.copy_upstream_to_k8s_upstream(up_id,
                            k8s_services = [
                                {
                                    'k8s' : 1,
                                    'k8s_namespace' : 'default',
                                    'k8s_service' : 'foo',
                                    'k8s_service_port' : 80,
                                }
                            ])

# Example2

client.use_app(app_id)

rules = client.get_all_rules()

k8s_up_id = client.copy_upstream_to_k8s_upstream(up_id = up_id,
                            k8s_services = [
                                {
                                    'k8s' : 1,
                                    'k8s_namespace' : 'default',
                                    'k8s_service' : 'foo',
                                    'k8s_service_port' : 80,
                                }
                            ],
                            rules = rules)

# put_k8s_upstream

ok = put_k8s_upstream(**kwargs)

Description of dict **kwargs:

# servers

Description of array servers in **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

ok = client.put_k8s_upstream(up_id, name = 'origin-upstream',
                    k8s_services = [
                        {
                            'k8s' : 1,
                            'k8s_namespace' : 'default',
                            'k8s_service' : 'foo',
                            'k8s_service_port' : 80,
                        }
                    ],
                    health_checker = {
                        'type': 'http',
                        'http_req_uri': '/status',
                        'http_req_host': 'test.com',
                        'interval': 3,
                        'interval_unit': 'sec',
                        'timeout': 1,
                        'fall': 3,
                        'rise': 2,
                        'valid_statuses': [200, 302],
                        'report_interval': 3,
                        'report_interval_unit': 'min'
                    })

# get_k8s_upstream

data = get_k8s_upstream(up_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

data = client.get_k8s_upstream(up_id)

# del-k8s-upstream

ok = del_k8s_upstream(up_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')


ok = client.del_k8s_upstream(up_id)

# get_all_k8s_upstreams

upstreams = client.get_all_k8s_upstreams()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

upstreams = client.get_all_k8s_upstreams(app_id)

# new_rule

rule_id = new_rule(**kwargs)

Description of dict **kwargs:

# condition

Description of array condition in **kwargs:

# conseq

Description of conseq in **kwargs:

conseq can be a dict or a list, below is an example of dict.

# Example 1

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

condition = [
    {
        'var': 'host',
        'val': 'con.' + APEX
    },
    {
        'var': ['req-header', 'Referer'],
        'vals': [
            'foo.com',
            ['foo\d+', 'rx'],
            ['foo*', 'wc']
        ]
    }
]

conseq = {
    'enable-websocket': {},
    'redirect': {'url': '/cn/2017/', 'code': 302},
    'user-code': {'el': 'true => say(\"hello\");'}
}

rule_id = client.new_rule(condition = condition, conseq = conseq)

The dict is not guaranteed to be in order, and cannot set the same action repeatedly. So it is recommended to use the usage of the following list instead of dict:

# Example 2

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

condition = [
            {'var': 'host', 'val': 'con.' + APEX},
            {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
        ]

conseq = [
            {'set-proxy-header': {
                'header': 'Foo',
                'value': 'default',
            }},
            {'set-proxy-header': {
                'header': 'Host',
                'value': "orig",
            }},
            {'print': {
                'msg': 'hello'
            }}
        ]

rule_id = client.new_rule(condition = condition, conseq = conseq)

# waf

Description of array waf in **kwargs:

# Example of waf rule

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

user_defined_waf_rule_id = client.new_global_waf_rule(name = 'foo', code = "uri-arg('foo') => waf-mark-risk(level: 'definite', msg: 'found foo');")

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

condition = [{'var': 'uri', 'op': 'prefix', 'val': '/foo'}]

waf_rule = {'rule_sets': [user_defined_waf_rule_id], 'robots': True, 'generic': True, 'inject': True, 'action': '403 Forbidden', 'threshold': 'low'}

rule_id = client.new_rule(condition = condition, waf = waf_rule)

# proxy

Description of array proxy in **kwargs:

# upstreams

Description of array upstreams and backup_upstreams in **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

up_id = client.new_upstream(name = 'origin-upstream',
                    servers = [
                        {'ip': '172.22.31.1', 'port': 80},
                        {'ip': '172.22.31.2', 'port': 80, 'weight': 2}
                    ])

k8s_up_id = client.new_k8s_upstream(
    name='k8s-upstream',
    k8s_services = [
        {
            'k8s' : k8s_id,
            'k8s_namespace' : 'default',
            'k8s_service' : 'test-hello',
            'k8s_service_port' : 80,
        }
    ])

ok = client.put_upstream(up_id, name = 'origin-upstream',
                              servers = [
                                {'ip': '172.22.31.1', 'port': 8080},
                                {'ip': '172.22.31.2', 'port': 8080, 'weight': 1}
                              ])

backup_up_id = client.new_upstream(name = 'backup-upstream',
                                        servers = [
                                            {'ip': '172.22.31.3', 'port': 80},
                                            {'ip': '172.22.31.4', 'port': 80, 'weight': 3}
                                        ])

proxy_rule = {
            'upstreams': [{'upstream': up_id, 'weight': 2}],
            'backup_upstreams': [{'upstream': backup_up_id}],
            'upstream_el_code': '',
            'retries': 2,
            "retry_condition": ["invalid_header", "http_500"],
            "balancer_algorithm": "hash",
            "balancer_vars": [
                {"name":"uri"},
                {
                    "name":"uri-arg",
                    "args":"foo"
                }
            ]
        }

rule_id = client.new_rule(proxy = proxy_rule)

k8s_proxy_rule = {
            'upstreams': [{'k8s_upstream': up_id, 'weight': 2}],
            'upstream_el_code': '',
            'retries': 2,
            "retry_condition": ["invalid_header", "http_500"],
            "balancer_algorithm": "hash",
            "balancer_vars": [
                {"name":"uri"},
                {
                    "name":"uri-arg",
                    "args":"foo"
                }
            ]
        }

k8s_rule_id = client.new_rule(proxy = k8s_proxy_rule)

# cache

Description of array cache in **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

condition = [{'var': 'client-country', 'op': 'eq', 'val': 'CN'}]
# cache_key = ['uri', 'query-string', 'client-city']
# or
cache_key = [
    {'name': 'uri'},
    {'name':'query-string'},
    {'name': 'client-city', 'args': 'first-x-forwarded-addr'}
]

default_ttls = [
    {
        'ttl_unit': "min", 'status': 200, 'ttl': 1
    }, {
        'ttl_unit': "min", 'status': 301, 'ttl': 1
    }
]
cache_rule = {'cache_key': cache_key, 'default_ttls': default_ttls}

rule_id = client.new_rule(condition = condition, cache = cache_rule)

# content

Description of array content in **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

condition = [{'var': 'uri', 'op': 'eq', 'val': '/favicon.ico'}]
file_id = client.upload_favicon(name = 'test', favicon_content = 'content', gid=[1])

rule_id = client.new_rule(condition = condition, content = {'favicon': file_id})

# put_rule

ok = put_rule(**kwargs)

Description of dict **kwargs:

# condition

Description of array condition in **kwargs:

# conseq

Description of array conseq in **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

condition = [
            {'var': 'host', 'val': 'con.' + APEX},
            {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
        ]

conseq = {
    'enable-websocket': {},
    'redirect': {'url': '/cn/2017/', 'code': 302}
}

rule_id = client.new_rule(condition = condition, conseq = conseq)

conseq['redirect']['url'] = '/cn/2018/'

ok = client.put_rule(rule_id = rule_id, condition = condition, conseq = conseq)

# get_rule

ok = get_rule(rule_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

condition = [
            {'var': 'host', 'val': 'con.' + APEX},
            {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
        ]

conseq = {
    'enable-websocket': {},
    'redirect': {'url': '/cn/2017/', 'code': 302}
}

rule_id = client.new_rule(condition = condition, conseq = conseq)

data = client.get_rule(rule_id)

# del_rule

ok = del_rule(rule_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

condition = [
            {'var': 'host', 'val': 'con.' + APEX},
            {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
        ]

conseq = {
    'enable-websocket': {},
    'redirect': {'url': '/cn/2017/', 'code': 302}
}

rule_id = client.new_rule(condition = condition, conseq = conseq)

conseq['redirect']['url'] = '/cn/2018/'

ok = client.del_rule(rule_id)

# get_all_rules

rules = get_all_rules(app_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

condition = [{'var': 'client-country', 'op': 'eq', 'val': 'CN'}]
cache_key = ['uri', 'query-string', 'client-city']
cache_rule = {'cache_key': cache_key}
rule_id = client.new_rule(condition = condition, cache = cache_rule, top = 1)

condition = [
    {'var': 'host', 'val': 'con.foo.com'},
    {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
]
conseq = {
    'enable-websocket': {},
    'redirect': {'url': '/cn/2017/', 'code': 302}
}
rule_id = client.new_rule(condition = condition, conseq = conseq, last = True)

data = client.get_all_rules()

# reorder_rules

ok = reorder_rules(orders)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

# swap the order of rule IDs 2 and 3
new_orders = {
    1: 1,
    2: 3,
    3: 2,
}
data = client.reorder_rules(new_orders)

# get_global_actions_used_in_app

rules = get_global_actions_used_in_app(app_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

condition = [
            {'var': 'host', 'val': 'con.' + APEX},
            {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
        ]

conseq = {
    'enable-websocket': {},
    'redirect': {'url': '/cn/2017/', 'code': 302}
}

name = "test-actions"

client.new_global_rule(condition=condition, conseq=conseq, name=name)

rule_ids = client.get_global_actions_used_in_app(app_id)

# get_all_rules_by_app_domain

rules = get_all_rules_by_app_domain(domain)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

condition = [{'var': 'client-country', 'op': 'eq', 'val': 'CN'}]
cache_key = ['uri', 'query-string', 'client-city']
cache_rule = {'cache_key': cache_key}
rule_id = client.new_rule(condition = condition, cache = cache_rule, top = 1)

condition = [
    {'var': 'host', 'val': 'foo.com'},
    {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
]
conseq = {
    'enable-websocket': {},
    'redirect': {'url': '/cn/2017/', 'code': 302}
}
rule_id = client.new_rule(condition = condition, conseq = conseq, last = True)

data = client.get_all_rules_by_app_domain('orig.foo.com')

# get_all_rules_by_upstream_ip

rules = get_all_rules_by_upstream_ip(domain)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

upstream_ip = '172.22.31.2'
up_id = client.new_upstream(name = 'origin-upstream',
                                         servers = [
                                             {'domain': 'test.com', 'port': 80},
                                             {'ip': upstream_ip, 'port': 80, 'weight': 2}
                                         ])

proxy_rule = {
            'upstreams': [{'upstream': up_id, 'weight': 2}],
            'retries': 2,
            "retry_condition": ["invalid_header", "http_500"],
            "balancer_algorithm": "hash",
            "balancer_vars": [
                {"name": "uri"},
                {
                    "name": "uri-arg",
                    "args": "foo"
                }
            ]
        }

rule_id = client.new_rule(proxy = proxy_rule, top = 1)

data = client.get_all_rules_by_upstream_ip(upstream_ip)

for app_id, rules in data.items():
    print(app_id)

# get_all_waf_rules

rules = get_all_waf_rules(app_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

condition = [{'var': 'client-country', 'op': 'eq', 'val': 'JP'}]
waf_rule = {'robots': False, 'generic': True, 'inject': True, 'action': '403 Forbidden', 'threshold': 'high'}
rule_id = client.new_rule(condition = condition, waf = waf_rule, last = True)

data = client.get_all_waf_rules()

# set_le_cert

cert_id = set_le_cert(**kwargs)

Description of array **kwargs:

# put_le_cert

cert_id = put_le_cert(**kwargs)

Description of array **kwargs:

# get_le_cert

data = get_le_cert(cert_id)

Description of return value data:

# set_cert_key

cert_id = set_cert_key(**kwargs)

Description of array **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

key_file = os.path.join('tests', 'key.pem')
cert_file = os.path.join('tests', 'cert.pem')
with open(key_file) as f:
    key = f.read()
with open(cert_file) as f:
    cert = f.read()

cert_id = client.set_cert_key(key = key, cert = cert)

# put_cert_key

cert_id = put_cert_key(**kwargs)

Description of array **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

key_file = os.path.join('tests', 'key.pem')
cert_file = os.path.join('tests', 'cert.pem')
with open(key_file) as f:
    key = f.read()
with open(cert_file) as f:
    cert = f.read()

cert_id = client.set_cert_key(key = key, cert = cert)

new_key_file = os.path.join('tests', 'new_key.pem')
new_cert_file = os.path.join('tests', 'new_cert.pem')
with open(new_key_file) as f:
    new_key = f.read()
with open(new_cert_file) as f:
    new_cert = f.read()

ok = client.put_cert_key(cert_id = cert_id, key = new_key, cert = new_cert)

# get_cert_key

cert_id = get_cert_key(cert_id)

Description of array **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

key_file = os.path.join('tests', 'key.pem')
cert_file = os.path.join('tests', 'cert.pem')
with open(key_file) as f:
    key = f.read()
with open(cert_file) as f:
    cert = f.read()

cert_id = client.set_cert_key(key = key, cert = cert)

data = client.get_cert_key(cert_id)

# get_all_cert_keys

cert_id = get_all_cert_keys()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

key_file = os.path.join('tests', 'key.pem')
cert_file = os.path.join('tests', 'cert.pem')
with open(key_file) as f:
    key = f.read()
with open(cert_file) as f:
    cert = f.read()

cert_id = client.set_cert_key(key = key, cert = cert)

data = client.get_all_cert_keys()

# del_cert_key

ok = del_cert_key(cert_id)

Description of array **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

key_file = os.path.join('tests', 'key.pem')
cert_file = os.path.join('tests', 'cert.pem')
with open(key_file) as f:
    key = f.read()
with open(cert_file) as f:
    cert = f.read()

cert_id = client.set_cert_key(key = key, cert = cert)

ok = client.del_cert_key(cert_id)

# new_el

ok = new_el(**kwargs)

Description of array **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

code = "true => print('hello, world');"

ok = client.new_el(phase = 'req-rewrite', code = code, pre = True)

# new_release

ok = new_release()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

code = "true => print('hello, world');"

ok = client.new_el(phase = 'req-rewrite', code = code, pre = True)

ok = client.new_release()

# pending_changes

changes = pending_changes()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

code = "true => print('hello, world');"

ok = client.new_el(phase = 'req-rewrite', code = code, pre = True)

changes = client.pending_changes()

# sync_status

total, synced = sync_status()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

code = "true => print('hello, world');"

ok = client.new_el(phase = 'req-rewrite', code = code, pre = True)

ok = client.new_release()

total, synced = client.sync_status()
if total == synced:
    print('the new release has been synced to all nodes')

# use_dns_app

ok = use_dns_app(dns_id)

Returns True if success else False.

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

client.use_dns_app(10)

# new_dns_app

dns_id = new_dns_app(**kwargs)

Description of array **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

authority = [
            {'domain': 'ns1.foo.com', 'ttl': '2 hour'},
            {'domain': 'ns2.foo.com', 'ttl': '1 day'}
        ]
soa_email = 'admin@foo.com'

dns_id = client.new_dns_app(authority = authority, soa_email = soa_email, zone = 'foo.com')

# put_dns_app

ok = put_dns_app(**kwargs)

Description of array **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

authority = [
            {'domain': 'ns1.foo.com', 'ttl': '2 hour'},
            {'domain': 'ns2.foo.com', 'ttl': '1 day'}
        ]
soa_email = 'admin@foo.com'

dns_id = client.new_dns_app(authority = authority, soa_email = soa_email, zone = 'foo.com')

authority = [
            {'domain': 'ns1.foo.com', 'ttl': '4 hour'},
            {'domain': 'ns2.foo.com', 'ttl': '1 day'}
        ]
ok = client.put_dns_app(authority = authority, soa_email = soa_email, zone = 'foo.com')

# get_dns_app

data = get_dns_app(dns_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

authority = [
            {'domain': 'ns1.foo.com', 'ttl': '2 hour'},
            {'domain': 'ns2.foo.com', 'ttl': '1 day'}
        ]
soa_email = 'admin@foo.com'

dns_id = client.new_dns_app(authority = authority, soa_email = soa_email, zone = 'foo.com')

dat = client.get_dns_app(dns_id)

# del_dns_app

ok = del_dns_app(dns_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

authority = [
            {'domain': 'ns1.foo.com', 'ttl': '2 hour'},
            {'domain': 'ns2.foo.com', 'ttl': '1 day'}
        ]
soa_email = 'admin@foo.com'

dns_id = client.new_dns_app(authority = authority, soa_email = soa_email, zone = 'foo.com')

dat = client.del_dns_app(dns_id)

# new_dns_record

record_id = new_dns_record(**kwargs)

Description of array **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

authority = [
            {'domain': 'ns1.foo.com', 'ttl': '2 hour'},
            {'domain': 'ns2.foo.com', 'ttl': '1 day'}
        ]
soa_email = 'admin@foo.com'

dns_id = client.new_dns_app(authority = authority, soa_email = soa_email, zone = 'foo.com')

record_id = client.new_dns_record(
    sub_domain = 'bar', record_type = 'TXT', text = 'text string')
client.new_dns_record(
    sub_domain='bar', record_type='A', ip='127.0.0.1')
client.new_dns_record(
    sub_domain='bar', record_type='CNAME', domain='test.com')
client.new_dns_record(
    sub_domain='bar', record_type='MX', domain='test.com', priority=3)

# put_dns_record

ok = put_dns_record(**kwargs)

Description of array **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

authority = [
            {'domain': 'ns1.foo.com', 'ttl': '2 hour'},
            {'domain': 'ns2.foo.com', 'ttl': '1 day'}
        ]
soa_email = 'admin@foo.com'

dns_id = client.new_dns_app(authority = authority, soa_email = soa_email, zone = 'foo.com')

record_id = client.new_dns_record(sub_domain = 'bar', record_type = 'TXT', text = 'text string')

ok = client.put_dns_record(record_id = record_id, sub_domain = 'a.bar', record_type = 'TXT', text = 'text string')

# get_dns_record

data = get_dns_record(record_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

authority = [
            {'domain': 'ns1.foo.com', 'ttl': '2 hour'},
            {'domain': 'ns2.foo.com', 'ttl': '1 day'}
        ]
soa_email = 'admin@foo.com'

dns_id = client.new_dns_app(authority = authority, soa_email = soa_email, zone = 'foo.com')

record_id = client.new_dns_record(sub_domain = 'bar', record_type = 'TXT', text = 'text string')

data = client.get_dns_record(record_id)

# del_dns_record

ok = del_dns_record(record_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

authority = [
            {'domain': 'ns1.foo.com', 'ttl': '2 hour'},
            {'domain': 'ns2.foo.com', 'ttl': '1 day'}
        ]
soa_email = 'admin@foo.com'

dns_id = client.new_dns_app(authority = authority, soa_email = soa_email, zone = 'foo.com')

record_id = client.new_dns_record(sub_domain = 'bar', record_type = 'TXT', text = 'text string')

ok = client.del_dns_record(record_id)

# set_global_cert_key

cert_id = set_global_cert_key(**kwargs)

Description of array **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

key_file = os.path.join('tests', 'key.pem')
cert_file = os.path.join('tests', 'cert.pem')
with open(key_file) as f:
    key = f.read()
with open(cert_file) as f:
    cert = f.read()

cert_id = client.set_global_cert_key(key = key, cert = cert)

# put_global_cert_key

cert_id = put_global_cert_key(**kwargs)

Description of array **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

key_file = os.path.join('tests', 'key.pem')
cert_file = os.path.join('tests', 'cert.pem')
with open(key_file) as f:
    key = f.read()
with open(cert_file) as f:
    cert = f.read()

cert_id = client.set_global_cert_key(key = key, cert = cert)

new_key_file = os.path.join('tests', 'new_key.pem')
new_cert_file = os.path.join('tests', 'new_cert.pem')
with open(new_key_file) as f:
    new_key = f.read()
with open(new_cert_file) as f:
    new_cert = f.read()

ok = client.put_global_cert_key(cert_id = cert_id, key = new_key, cert = new_cert)

# get_global_cert_key

cert_id = get_global_cert_key(cert_id)

Description of array **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

key_file = os.path.join('tests', 'key.pem')
cert_file = os.path.join('tests', 'cert.pem')
with open(key_file) as f:
    key = f.read()
with open(cert_file) as f:
    cert = f.read()

cert_id = client.set_global_cert_key(key = key, cert = cert)

data = client.get_global_cert_key(cert_id)

# del_global_cert_key

ok = del_global_cert_key(cert_id)

Description of array **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

key_file = os.path.join('tests', 'key.pem')
cert_file = os.path.join('tests', 'cert.pem')
with open(key_file) as f:
    key = f.read()
with open(cert_file) as f:
    cert = f.read()

cert_id = client.set_global_cert_key(key = key, cert = cert)

ok = client.del_global_cert_key(cert_id)

# add_global_user

app_id = add_global_user(name, pwd, gid)

Description of parameters:

# Example

import random
from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

write = ''.join([random.choice(string.ascii_letters) for n in range(10)])
pwd = ''.join([random.choice(string.ascii_letters + string.digits) for n in range(12)])

ok = client.add_global_user(name = write, pwd = pwd, gid = [1])

# search_global_user

ok = search_global_user(name)

Description of parameters:

# Example

import random
from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

write = ''.join([random.choice(string.ascii_letters) for n in range(10)])
pwd = ''.join([random.choice(string.ascii_letters + string.digits) for n in range(12)])

ok = client.add_global_user(name = write, pwd = pwd, can_create_app = True, role = 'user')

data = client.search_global_user(write)
user_id = data.get('id')

# get_all_global_users

data = get_all_global_users(detail)

# Example

import random
from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

write = ''.join([random.choice(string.ascii_letters) for n in range(10)])
pwd = ''.join([random.choice(string.ascii_letters + string.digits) for n in range(12)])

ok = client.add_global_user(name = write, pwd = pwd, can_create_app = True, role = 'user')

data = client.get_all_global_users()
data = client.get_all_global_users(True)

# add_app_user

app_id = add_app_user(name, read, write, release)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')
id = client.add_app_user(name = 'only_reader', write = False, release = False)

# put_app_user

app_id = put_app_user(id, name, read, write, release)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')
id = client.add_app_user(name = 'only_reader', write = False, release = False)

ok = client.put_app_user(id = id, name = 'master', write = True, release = True)

# get_app_user

data = get_app_user(id, name, app_id, user_id)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')
id = client.add_app_user(name = 'only_reader', write = False, release = False)

data = client.get_app_user(name = 'only_reader')

# del_app_user

data = del_app_user(id, name, app_id, user_id)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')
id = client.add_app_user(name = 'only_reader', write = False, release = False)

ok = client.del_app_user(name = 'only_reader')

# get_all_app_users

data = get_all_app_users(app_id)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')
id = client.add_app_user(name = 'only_reader', write = False, release = False)

data = client.get_all_app_users()

# add_user_for_all_apps

ok = add_user_for_all_apps(name, read, write, release)

Description of parameters:

# Example

import random
from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

write = ''.join([random.choice(string.ascii_letters) for n in range(10)])
pwd = ''.join([random.choice(string.ascii_letters + string.digits) for n in range(12)])
ok = client.add_global_user(name = write, pwd = pwd, can_create_app = True, role = 'user')

data = client.add_user_for_all_apps(name = write)

# add-all-users-for-app

ok = add_all_users_for_app(app_id, read, write, release)

Description of parameters:

# Example

import random
from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

write = ''.join([random.choice(string.ascii_letters) for n in range(10)])
pwd = ''.join([random.choice(string.ascii_letters + string.digits) for n in range(12)])

ok = client.add_global_user(name = write, pwd = pwd, can_create_app = True, role = 'user')
data = client.add_all_users_for_app(release = True)

# new_global_rule

rule_id = new_global_rule(**kwargs)

Description of dict **kwargs:

# condition

Description of array condition in **kwargs:

# conseq

Description of array conseq in **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

condition = [
            {'var': 'host', 'val': 'con.' + APEX},
            {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
        ]

conseq = {
    'enable-websocket': {},
    'redirect': {'url': '/cn/2017/', 'code': 302}
}

rule_id = client.new_global_rule(condition = condition, conseq = conseq, gid=[1])

# put_global_rule

ok = put_global_rule(**kwargs)

Description of dict **kwargs:

# condition

Description of array condition in **kwargs:

# conseq

Description of array conseq in **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

condition = [
            {'var': 'host', 'val': 'con.' + APEX},
            {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
        ]

conseq = {
    'enable-websocket': {},
    'redirect': {'url': '/cn/2017/', 'code': 302}
}

rule_id = client.new_global_rule(condition = condition, conseq = conseq)

conseq['redirect']['url'] = '/cn/2018/'

ok = client.put_global_rule(rule_id = rule_id, condition = condition, conseq = conseq)

# get_global_rule

ok = get_global_rule(rule_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

condition = [
            {'var': 'host', 'val': 'con.' + APEX},
            {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
        ]

conseq = {
    'enable-websocket': {},
    'redirect': {'url': '/cn/2017/', 'code': 302}
}

rule_id = client.new_global_rule(condition = condition, conseq = conseq)

data = client.get_global_rule(rule_id)

# get_global_action_by_name

rule_id = get_global_action_by_name(name)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

condition = [
            {'var': 'host', 'val': 'con.' + APEX},
            {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
        ]

conseq = {
    'enable-websocket': {},
    'redirect': {'url': '/cn/2017/', 'code': 302}
}

name = "test-actions"

client.new_global_rule(condition=condition, conseq=conseq, name=name)

rule_id = client.get_global_action_by_name('test-actions')

# get_all_global_rules

ok = get_all_global_rules()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

condition = [
            {'var': 'host', 'val': 'con.' + APEX},
            {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
        ]

conseq = {
    'enable-websocket': {},
    'redirect': {'url': '/cn/2017/', 'code': 302}
}

rule_id = client.new_global_rule(condition = condition, conseq = conseq)

data = client.get_all_global_rules()

# del_global_rule

ok = del_global_rule(rule_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

condition = [
            {'var': 'host', 'val': 'con.' + APEX},
            {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
        ]

conseq = {
    'enable-websocket': {},
    'redirect': {'url': '/cn/2017/', 'code': 302}
}

rule_id = client.new_global_rule(condition = condition, conseq = conseq)

conseq['redirect']['url'] = '/cn/2018/'

ok = client.del_global_rule(rule_id)

# new_global_var

var_id = new_global_var(**kwargs)

Description of dict **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

var_id = client.new_global_var(name = 'is-whitelist', var_type = 'string', default = 'no')

# put_global_var

ok = put_global_var(**kwargs)

Description of dict **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

var_id = client.new_global_var(name = 'is-whitelist', var_type = 'string', default = 'no')

ok = client.put_global_var(var_id = var_id, name = 'is-whitelist', var_type = 'string', default = 'yes')

# get_global_var

data = get_global_var(var_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

var_id = client.new_global_var(name = 'is-whitelist', var_type = 'string', default = 'no')

data = client.get_global_var(var_id)

# get_all_global_vars

data = get_all_global_vars()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

var_id = client.new_global_var(name = 'is-whitelist', var_type = 'string', default = 'no')

data = client.get_all_global_vars()

# del_global_var

ok = del_global_var(var_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

var_id = client.new_global_var(name = 'is-whitelist', var_type = 'string', default = 'no')

ok = client.del_global_var(var_id)

# get_global_ngx_config

data = get_global_ngx_config()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

data = client.get_global_ngx_config()

# set_global_ngx_config

data = set_global_ngx_config(opts)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

opts = {'keepalive_timeout': 10, 'enable_open_file_cache': False}
ok = client.set_global_ngx_config(opts)

# get_global_misc_config

data = get_global_misc_config()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

data = client.get_global_misc_config()

# set_global_misc_config

data = set_global_misc_config(opts)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

opts = {'enabled_req_id': True}
ok = client.set_global_misc_config(opts)

# get_request_id_status

status = get_request_id_status()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

status = client.get_request_id_status()

# enable_request_id

ok = enable_request_id()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

ok = client.enable_request_id()

# disable_request_id

ok = disable_request_id()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

ok = client.disable_request_id()

# new_global_waf_rule

rule_id = new_global_waf_rule(**kwargs)

Description of dict **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

waf_rule_id = client.new_global_waf_rule(name = 'foo', code = "uri-arg('foo') => waf-mark-risk(level: 'definite', msg: 'found foo');")

# put_global_waf_rule

ok = put_global_waf_rule(**kwargs)

Description of dict **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

waf_rule_id = client.new_global_waf_rule(name = 'foo', code = "uri-arg('foo') => waf-mark-risk(level: 'definite', msg: 'found foo');")

ok = client.put_global_waf_rule(rule_id = waf_rule_id, name = 'bar', code = "uri-arg('bar') => waf-mark-risk(level: 'definite', msg: 'found bar');")

# get_global_waf_rule

data = get_global_waf_rule(rule_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

waf_rule_id = client.new_global_waf_rule(name = 'foo', code = "uri-arg('foo') => waf-mark-risk(level: 'definite', msg: 'found foo');")

data = client.get_global_waf_rule(waf_rule_id)

# del_global_waf_rule

ok = del_global_waf_rule(rule_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

waf_rule_id = client.new_global_waf_rule(name = 'foo', code = "uri-arg('foo') => waf-mark-risk(level: 'definite', msg: 'found foo');")

ok = client.del_global_waf_rule(waf_rule_id)

# get_all_global_waf_rules

data = get_all_global_waf_rules(detail = False)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

waf_rule_id = client.new_global_waf_rule(name = 'foo', code = "uri-arg('foo') => waf-mark-risk(level: 'definite', msg: 'found foo');")

data = client.get_all_global_waf_rules()

# new_global_action

rule_id = new_global_action(**kwargs)

Description of dict **kwargs:

# condition

Description of array condition in **kwargs:

# conseq

Description of array conseq in **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

name = 'test'
condition = [
    {'var': 'req-method', 'vals': ['GET', 'POST', 'HEAD']}
]
conseq = [
    {
        'exit': {'code': 403}
    }
]
action_id = client.new_global_action(name = name, condition = condition, conseq = conseq, gid=[1])

# put_global_action

ok = put_global_action(**kwargs)

Description of dict **kwargs:

# condition

Description of array condition in **kwargs:

# conseq

Description of array conseq in **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

name = 'test'
condition = [
    {'var': 'req-method', 'vals': ['GET', 'POST', 'HEAD']}
]
conseq = [
    {
        'exit': {'code': 403}
    }
]
action_id = client.new_global_action(name = name, condition = condition, conseq = conseq)

conseq = [
            {
                'exit': {'code': 404}
            }
        ]
ok = client.put_global_action(name = name, action_id = action_id, condition = condition, conseq = conseq, gid=[1])

# get_global_action

ok = get_global_action(action_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

name = 'test'
condition = [
    {'var': 'req-method', 'vals': ['GET', 'POST', 'HEAD']}
]
conseq = [
    {
        'exit': {'code': 403}
    }
]
action_id = client.new_global_action(name = name, condition = condition, conseq = conseq)

data = client.get_global_action(action_id)

# del_global_action

ok = del_global_action(action_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

name = 'test'
condition = [
    {'var': 'req-method', 'vals': ['GET', 'POST', 'HEAD']}
]
conseq = [
    {
        'exit': {'code': 403}
    }
]
action_id = client.new_global_action(name = name, condition = condition, conseq = conseq)

ok = client.del_global_action(action_id)

# count_global_actions

count = count_global_actions()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

ok = client.count_global_actions()

# get_all_global_actions

data = get_all_global_actions()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

data = client.get_all_global_actions()

# new_user_var

var_id = new_user_var(**kwargs)

Description of dict **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

var_id = client.new_user_var(name = 'is-whitelist', var_type = 'string', default = 'no')

# put_user_var

ok = put_user_var(**kwargs)

Description of dict **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

var_id = client.new_user_var(name = 'is-whitelist', var_type = 'string', default = 'no')

ok = client.put_user_var(var_id = var_id, name = 'is-whitelist', var_type = 'string', default = 'yes')

# get_user_var

data = get_user_var(var_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

var_id = client.new_user_var(name = 'is-whitelist', var_type = 'string', default = 'no')

data = client.get_user_var(var_id)

# del_user_var

ok = del_user_var(var_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

var_id = client.new_user_var(name = 'is-whitelist', var_type = 'string', default = 'no')

ok = client.del_user_var(var_id)

# **node_sync_status

**

data = node_sync_status()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

data = client.node_sync_status()
for node_id, delay in data.items():
    if delay > 0:
        print('WARNING: node id {}: releases behind {}'.format(str(node_id), str(delay)))

# upload_static_file

file_id = upload_static_file(**kwargs)

Description of dict **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

file_id = client.upload_static_file(content = 'test_content', label = '500.html', gid=[1])

# get_static_file

data = get_static_file(file_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

file_id = client.upload_static_file(content = 'test_content', label = '500.html')

data = client.get_static_file(file_id)

# del_static_file

ok = del_static_file(file_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

file_id = client.upload_static_file(content = 'test_content', label = '500.html')

ok = client.del_static_file(file_id)

# new_waf_whitelist

rule_id = new_waf_whitelist(**kwargs)

Description of dict **kwargs:

# condition

Description of array condition in **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

condition = [
            {'var': 'host', 'val': 'con.foo.com'},
            {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
        ]

id = client.new_waf_whitelist(condition = condition, rule_sets = [1, 2])

# put_waf_whitelist

ok = put_waf_whitelist(**kwargs)

Description of dict **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

condition = [
            {'var': 'host', 'val': 'con.foo.com'},
            {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
        ]

id = client.new_waf_whitelist(condition = condition, rule_sets = [1, 2])

ok = client.put_waf_whitelist(whitelist_id = id, condition = condition, rule_sets = [1])

# get_waf_whitelist

data = get_waf_whitelist(whitelist_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

condition = [
            {'var': 'host', 'val': 'con.foo.com'},
            {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
        ]

id = client.new_waf_whitelist(condition = condition, rule_sets = [1, 2])
data = client.get_waf_whitelist(id)

# del_waf_whitelist

ok = del_waf_whitelist(whitelist_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

condition = [
            {'var': 'host', 'val': 'con.foo.com'},
            {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
        ]

id = client.new_waf_whitelist(condition = condition, rule_sets = [1, 2])
ok = client.del_waf_whitelist(id)

# get_all_waf_whitelists

data = get_all_waf_whitelists()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

condition = [
            {'var': 'host', 'val': 'con.foo.com'},
            {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
        ]

id = client.new_waf_whitelist(condition = condition, rule_sets = [1, 2])
data = client.get_all_waf_whitelists()

# get_healthcheck_status

data = get_healthcheck_status(node_id, page=1, page_size=1000)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

data = client.node_sync_status()
for node_id, node_info in data.items():
    node_id = int(node_id)
    data = client.get_healthcheck_status(node_id, 1, 1000)

# new_ip_list

data = new_ip_list(name=None, type='ipv4', items=None)

Description of parameters:

# items

Description of array items:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

ok = client.new_ip_list(name = 'ip-list-1',
                        type = 'ipv4',
                        items = [
                            {'ip': '127.0.0.0/24'},
                            {'ip': '192.168.1.0/24'}
                        ])

# put_ip_list

data = put_ip_list(rule_id=None, name=None, type='ipv4', items=None)

Description of parameters:

# items

Description of array items:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

ok = client.put_ip_list(rule_id = 1, items = [ {'ip': '127.0.0.2'} ])

# del_ip_list

data = del_ip_list(rule_id=None)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

ok = client.del_ip_list(rule_id=1)

# get_ip_list

data = get_ip_list(rule_id=None)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

data = client.get_ip_list(rule_id=1)

# new_cluster_group

group_id = new_cluster_group(group_name)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

group_id = client.new_cluster_group('foo')

# put_cluster_group

ok = put_cluster_group(**kwargs)

Description of dict **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

group_id = client.new_cluster_group(group_name = 'foo')

ok = client.put_cluster_group(group_id = group_id, group_name = 'bar')

# get_cluster_group

data = get_cluster_group(group_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

group_id = client.new_cluster_group(group_name = 'foo')

data = client.get_cluster_group(group_id)

# get_all_cluster_groups

data = get_all_cluster_groups()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

group_id = client.new_cluster_group(group_name = 'foo')

data = client.get_all_cluster_groups()

# del_cluster_group

ok = del_cluster_group(group_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

group_id = client.new_cluster_group(group_name = 'foo')

ok = client.del_cluster_group(group_id)

# put_proxy_rule

ok = put_proxy_rule(**kwargs)

Description of dict **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

app_id = client.new_app(domains = ['orig.foo.com'], label = 'origin site for foo.com')

condition = [
            {'var': 'host', 'val': 'con.' + APEX},
            {'var': ['req-header', 'Referer'], 'vals': [['foo\d+', 'rx'], 'foo.com']}
        ]

conseq = {
    'enable-websocket': {},
    'redirect': {'url': '/cn/2017/', 'code': 302}
}

rule_id = client.new_rule(condition = condition, conseq = conseq)

proxy_rule = {
            'upstreams': [{'upstream': up_id, 'weight': 2}],
            'backup_upstreams': [{'upstream': backup_up_id}],
            'retries': -1,
            "retry_condition": ["invalid_header", "http_500"],
            "balancer_algorithm": "hash",
            "balancer_vars": [
                {"name":"uri"},
                {
                    "name":"uri-arg",
                    "args":"foo"
                }
            ]
        }

ok = client.put_proxy_rule(rule_id = rule_id, proxy = proxy_rule)

# decode_request_id

data = decode_request_id(request_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

data = client.decode_request_id('00000a00000c0826c9803222')

# {u'timestamp': 1531859760, u'node_id': 20, u'app_id': 3, u'is_stream': False, u'sequence': 12834}
print(data)

# search_waf_log

data = search_waf_log(request_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

request_id = "0000008000042c421ea80011"

data = client.search_waf_log(request_id)

# add_api_token

data = add_api_token(name=None, expire=0)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

data = client.add_api_token("name", 0)

# get_api_token

data = get_api_token(id=None, limit=20)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

data = client.get_api_token(id)

# or

data = client.get_api_token(None, 100)

# del_api_token

data = del_api_token(id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

data = client.del_api_token(id)

# get_all_gateway_tag

tags = get_all_gateway_tag()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

tags = client.get_all_gateway_tag()

for i, tag in enumerate(tags):
    print(i, tag)

# get_all_gateway

gateways = get_all_gateway()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

gateways = client.get_all_gateway()

for i, gateway in enumerate(gateways):
    print(i, gateway)

# add_gateway

id = add_gateway(name, partition_id, tag=None)

Description of args:

Description of return value:

type: number

1

# Example

default_partition_id = 1
id = client.add_gateway("my-cluster", default_partition_id)

# del_gateway

ok = del_gateway(gateway_id)

Description of args:

Description of return value:

type: number

true

# Example

gateway_id = 1
ok = client.del_gateway(gateway_id)

# get_app_metrics

metrics = get_app_metrics(id, start_time=None, end_time=None)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

metrics = client.get_app_metrics()

for i, mt in enumerate(metrics):
    print(i, mt)

# new_app_dymetrics

id = new_app_dymetrics(app_id=None, name=None, note=None, interval=60, sql=None)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

sql = 'select status, count(*) from reqs group by status'
dymetrics_id = client.new_app_dymetrics(app_id=1, name='test', sql=sql)

# put_app_dymetrics

ok = put_app_dymetrics(app_id=None, id=None, name=None, note=None, interval=60)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

sql = 'select status, count(*) from reqs group by status'
ok = client.put_app_dymetrics(app_id=app_id, id=dymetrics_id, name='test')

# del_app_dymetrics

ok = del_app_dymetrics(id)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

ok = client.del_app_dymetrics(app_id, dymetrics_id)

# get_app_dymetrics

data = get_app_dymetrics(id)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

data = client.get_app_dymetrics(app_id, dymetrics_id)

# get_all_app_dymetrics

data = get_all_app_dymetrics(app_id)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

data = client.get_all_app_dymetrics(app_id)

# get_app_dymetrics_data

data = get_app_dymetrics_data(app_id, id, chart_type='line', start_time=None, end_time=None, node_id=None)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

data = client.get_app_dymetrics_data(app_id, dymetrics_id)

# new_global_dymetrics

id = new_global_dymetrics(name=None, note=None, interval=60, sql=None)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

sql = 'select status, count(*) from reqs group by status'
dymetrics_id = client.new_global_dymetrics(name='test', sql=sql)

# put_global_dymetrics

ok = put_global_dymetrics(id=None, name=None, note=None, interval=60)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

sql = 'select status, count(*) from reqs group by status'
ok = client.put_global_dymetrics(id=dymetrics_id, name='test')

# del_global_dymetrics

ok = del_global_dymetrics(id)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

ok = client.del_global_dymetrics(dymetrics_id)

# get_global_dymetrics

data = get_global_dymetrics(id)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

data = client.get_global_dymetrics(dymetrics_id)

# get_all_global_dymetrics

data = get_all_global_dymetrics()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

data = client.get_all_global_dymetrics()

# get_global_dymetrics_data

data = get_global_dymetrics_data(id, chart_type='line', start_time=None, end_time=None, node_id=None)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

data = client.get_global_dymetrics_data(dymetrics_id)

# new_global_ip_list

data = new_global_ip_list(name=None, type='ipv4', items=None)

Description of parameters:

# items

Description of array items:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

ok = client.new_global_ip_list(name = 'ip-list-1',
                               type = 'ipv4',
                               items = [
                                   {'ip': '127.0.0.0/24'},
                                   {'ip': '192.168.1.0/24'}
                               ])

# put_global_ip_list

data = put_global_ip_list(rule_id=None, name=None, type='ipv4', items=None)

Description of parameters:

# items

Description of array items:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

ok = client.put_global_ip_list(rule_id = 1, items = [ {'ip': '127.0.0.2'} ])

# del_global_ip_list

data = del_global_ip_list(rule_id=None)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

ok = client.del_global_ip_list(rule_id=1)

# get_global_ip_list

data = get_global_ip_list(rule_id=None)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

data = client.get_global_ip_list(rule_id=1)

# node_monitor

data = node_monitor(node_id, start_time=None, end_time=None, step=60)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

node_id = 1
data = client.node_monitor(node_id)

# get_version

data = get_version()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

data = client.get_version()

# new_global_k8s

k8s_id = new_global_k8s(name=None, host=None, port=None, ssl_verify=True, token=None)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

k8s_id = client.new_global_k8s(name = "k8s", host = "192.168.1.1", port = 443, token = "xxxxx")

# put_global_k8s

ok = put_global_k8s(k8s_id=None, name=None, host=None, port=None, ssl_verify=True, token=None)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

ok = client.put_global_k8s(k8s_id = 1, name = "k8s", host = "192.168.1.1", port = 443, token = "xxxxx")

# get_global_k8s

data = get_global_k8s(k8s_id=None)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

data = client.get_global_k8s(k8s_id = 1)

# get_k8s_service_detail

data = get_k8s_service_detail(k8s_id=None)

Description of parameters:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

data = client.get_k8s_service_detail(k8s_id = 1)

# get_all_global_k8s

data = get_all_global_k8s()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

data = client.get_all_global_k8s()

# del_global_k8s

ok = del_global_k8s(k8s_id = None)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')

client.login()

ok = client.del_global_k8s(k8s_id = 1)

# new_global_upstream

up_id = new_global_upstream(**kwargs)

Description of dict **kwargs:

# servers

Description of array servers in **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

up_id = client.new_global_upstream(name = 'origin-upstream',
                            servers = [
                                {'ip': '172.22.31.1', 'port': 80},
                                {'ip': '172.22.31.2', 'port': 80, 'weight': 2}
                            ])

# put_global_upstream

ok = put_global_upstream(**kwargs)

Description of dict **kwargs:

# servers

Description of array servers in **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

up_id = client.new_global_upstream(name = 'origin-upstream',
                            servers = [
                                {'domain': 'a.com', 'port': 80},
                                {'ip': '172.22.31.2', 'port': 80, 'weight': 2}
                            ])

ok = client.put_global_upstream(up_id, name = 'origin-upstream',
                    servers = [
                        {'domain': 'test.com', 'port': 8080},
                        {'ip': '172.22.31.2', 'port': 8080, 'weight': 1}
                    ],
                    health_checker = {
                        'type': 'http',
                        'http_req_uri': '/status',
                        'http_req_host': 'test.com',
                        'interval': 3,
                        'interval_unit': 'sec',
                        'timeout': 1,
                        'fall': 3,
                        'rise': 2,
                        'valid_statuses': [200, 302],
                        'report_interval': 3,
                        'report_interval_unit': 'min'
                    })

# get_global_upstream

data = get_global_upstream(up_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

up_id = client.new_global_upstream(name = 'origin-upstream',
                            servers = [
                                {'ip': '172.22.31.1', 'port': 80},
                                {'ip': '172.22.31.2', 'port': 80, 'weight': 2}
                            ])

data = client.get_global_upstream(up_id)

# del-global-upstream

ok = del_global_upstream(up_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

up_id = client.new_global_upstream(name = 'origin-upstream',
                            servers = [
                                {'ip': '172.22.31.1', 'port': 80},
                                {'ip': '172.22.31.2', 'port': 80, 'weight': 2}
                            ])

ok = client.del_global_upstream(up_id)

# get_all_global_upstreams

upstreams = client.get_all_global_upstreams()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

up_id = client.new_global_upstream(name = 'origin-upstream',
                            servers = [
                                {'ip': '172.22.31.1', 'port': 80},
                                {'ip': '172.22.31.2', 'port': 80, 'weight': 2}
                            ])

upstreams = client.get_all_global_upstreams(up_id)

# new_global_k8s_upstream

k8s_up_id = new_global_k8s_upstream(**kwargs)

Description of dict **kwargs:

# k8s_services

Description of array k8s_services in **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

k8s_up_id = client.new_global_k8s_upstream(name = 'k8s-upstream',
                            k8s_services = [
                                {
                                    'k8s' : 1,
                                    'k8s_namespace' : 'default',
                                    'k8s_service' : 'foo',
                                    'k8s_service_port' : 80,
                                }
                            ])

# put_global_k8s_upstream

ok = put_global_k8s_upstream(**kwargs)

Description of dict **kwargs:

# servers

Description of array servers in **kwargs:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()


ok = client.put_global_k8s_upstream(up_id, name = 'origin-upstream',
                    k8s_services = [
                        {
                            'k8s' : 1,
                            'k8s_namespace' : 'default',
                            'k8s_service' : 'foo',
                            'k8s_service_port' : 80,
                        }
                    ],
                    health_checker = {
                        'type': 'http',
                        'http_req_uri': '/status',
                        'http_req_host': 'test.com',
                        'interval': 3,
                        'interval_unit': 'sec',
                        'timeout': 1,
                        'fall': 3,
                        'rise': 2,
                        'valid_statuses': [200, 302],
                        'report_interval': 3,
                        'report_interval_unit': 'min'
                    })

# get_global_k8s_upstream

data = get_global_k8s_upstream(up_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

data = client.get_global_k8s_upstream(up_id)

# del-global-k8s-upstream

ok = del_global_k8s_upstream(up_id)

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

ok = client.del_global_k8s_upstream(up_id)

# get_all_global_k8s_upstreams

upstreams = client.get_all_global_k8s_upstreams()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

upstreams = client.get_all_global_k8s_upstreams(app_id)

# get_all_nodes

nodes = client.get_all_nodes()

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

nodes = client.get_all_nodes()

# get_node

node = client.get_node(node_id, gateway_id=None)

Get node info by node id.

Description of args:

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

node = client.get_node(1)
node = client.get_node(1, gateway_id=1)

# get_node_by_mac_address

node = client.get_node_by_mac_address(mac_address)

Get node info by hardware id of node.

Description of args:

Description of return value:

type: dict

{
    "mac_address": "46:b1:5f:1d:fa:ea",
    "serial": "2655388572",
    "is_limited": false,
    "config": {
        "enable_qat": false
    },
    "name": "test-edge-node-75c5bf6969-65tgg\n",
    "id": 11,
    "external_ip": "172.20.0.2",
    "sync_status_utime": 0,
    "online_status": true,
    "internal_ip": "10.244.0.6",
    "hardware_id": "a11abe66fe25be7941bda81c3f358344",
    "is_healthy": true,
    "status": 1,
    "gateway_id": 14
}

# Example

from edge2client import Edge2Client

client = Edge2Client('http://127.0.0.1:8080', 'username', 'password')
client.login()

node = client.get_node_by_mac_address("e2:d1:d9:e0:c4:6e")

# put_node

node = client.put_node(node_id, gateway_id=None, **kwargs)

Update node info.

Description of args: