1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
#!@PYTHON@
# Copyright (C) 2017-2021 Internet Systems Consortium, Inc. ("ISC")
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
"""
Text client for Control Agent process
"""
# First, let's import the right kea_connector.
# We have two versions: one for python 2.x and another for python 3.x.
# Sadly, there's no unified way to handle http connections. The recommended
# way is to use Requests (http://docs.python-requests.org/en/master/), but
# that's a stand alone package that requires separate installation. One of
# the design requirements was to not require any additional packages, so
# the code uses standard libraries available in python. Hence two versions.
import sys
import signal
import argparse
from base64 import b64encode
sys.path.append('@PKGPYTHONDIR@')
from kea_conn import CARequest # CAResponse
if sys.version_info[0] == 2:
# This is Python 2.x
import kea_connector2 as kea_connector
def auth8(string):
"""Convert str into unicode"""
return unicode(string, 'utf-8')
elif sys.version_info[0] == 3:
# This is Python 3.x
import kea_connector3 as kea_connector
auth8 = str
else:
# This is... have no idea what it is.
raise SystemExit("Unknown python version:" + str(sys.version_info[0]))
def timeout_handler(signum, frame):
"""Connection timeout handler"""
del signum, frame
print("Connection timeout")
sys.exit(1)
VERSION = "@PACKAGE_VERSION@"
def shell_body():
"""
Second step: Need to parse command line parameters. We will use
argparse for that purpose. It does great job with having default
values, taking care of the help and sanity checking input
parameters.
"""
parser = argparse.ArgumentParser(description='kea-shell is a simple text '
'client that uses REST interface to '
'connect to Kea Control Agent.')
parser.add_argument('--host', type=str, default='127.0.0.1',
help='hostname of the CA to connect to '
'(default:; 127.0.0.1)')
parser.add_argument('--port', type=int, default=8000,
help='TCP port of the CA to connect to '
'(default: 8000)')
parser.add_argument('--path', type=str, default='',
help='Path of the URL to connect to '
'(default: "")')
parser.add_argument('--ca', type=str, default='',
help='File or directory name of the CA '
'(default: "" i.e. do not use HTTPS)')
parser.add_argument('--cert', type=str, default='',
help='File name of the client certificate '
'(default: "")')
parser.add_argument('--key', type=str, default='',
help='File name of the client private key '
'(default: "")')
parser.add_argument('--timeout', type=int, default='10',
help='Timeout (in seconds) when attempting to '
'connect to CA (default: 10)')
parser.add_argument('--service', nargs="?", action="append",
help='target specified service. If not specified,'
'control agent will receive command.')
parser.add_argument('--auth-user', type=auth8, default='',
help='Basic HTTP authentication user')
parser.add_argument('--auth-password', type=auth8, default='',
help='Basic HTTP authentication password')
parser.add_argument('command', type=str, nargs="?",
default='list-commands',
help='command to be executed. If not specified, '
'"list-commands" is used')
parser.add_argument('-v', action="store_true", help="Prints version")
cmd_args = parser.parse_args()
if cmd_args.v:
print(VERSION)
sys.exit(0)
# Ok, now it's time to put the parameters parsed into the structure to be
# used by the connection.
params = CARequest()
params.command = cmd_args.command
params.service = cmd_args.service
params.http_host = cmd_args.host
params.http_port = cmd_args.port
params.path += cmd_args.path
if cmd_args.ca:
params.ca = cmd_args.ca
params.scheme = 'https'
if (cmd_args.cert != '' and cmd_args.key == '') or \
(cmd_args.cert == '' and cmd_args.key != ''):
print("--cert and --key must be used together")
sys.exit(1)
if cmd_args.cert:
if cmd_args.ca == '':
print("--cert and --key with HTTPS disabled (no --ca)")
sys.exit(1)
params.cert = cmd_args.cert
if cmd_args.key:
# HTTPS check already done for the cert
params.key = cmd_args.key
if cmd_args.auth_user != '':
user = cmd_args.auth_user
password = cmd_args.auth_password
secret = b':'.join((user.encode('utf-8'), password.encode('utf-8')))
if sys.version_info[0] == 3:
params.auth = b64encode(secret).strip().decode('ascii')
else:
params.auth = b64encode(secret).strip().encode('ascii')
params.timeout = cmd_args.timeout
params.version = VERSION
# Load command processor
# @todo - command specific processing will be added as part of
# future work (either #5138 or #5139, whichever is implemented
# first)
# Read arguments from stdin (they're optional for some commands)
for line in sys.stdin:
params.args += line
# Now we have the arguments so we can build the request
params.generate_body()
params.generate_headers()
# Set the timeout timer. If the connection takes too long,
# it will send a signal to us.
signal.signal(signal.SIGALRM, timeout_handler)
signal.alarm(params.timeout)
# Ok, everything is ready. Let's send the command and get a response.
try:
resp = kea_connector.send_to_control_agent(params)
except Exception as exc:
print("Failed to run: " + str(exc))
sys.exit(1)
resp.print_response()
sys.exit(0)
if __name__ == "__main__":
shell_body()
|
