177 lines
6.0 KiB
Python
177 lines
6.0 KiB
Python
"""Zephir Client library
|
|
"""
|
|
from os.path import isfile
|
|
from requests import get, post
|
|
from json import dumps, loads
|
|
from typing import Dict
|
|
# import warnings
|
|
# from urllib3.exceptions import InsecureRequestWarning
|
|
|
|
from tiramisu_cmdline_parser import TiramisuCmdlineParser
|
|
from argparse import RawDescriptionHelpFormatter
|
|
from tiramisu_api import Config
|
|
|
|
from .config import config, TO_JSON
|
|
|
|
|
|
# warnings.simplefilter('ignore', InsecureRequestWarning)
|
|
|
|
|
|
class CucchiaiataParser(TiramisuCmdlineParser):
|
|
def print_help(self, *args, **kwargs):
|
|
if not self.config.option('message').value.get():
|
|
self.remove_empty_od = False
|
|
return super().print_help(*args, **kwargs)
|
|
|
|
|
|
class Parser:
|
|
def __init__(self):
|
|
# retrieve config's option
|
|
self.cucchiaiata_config = config
|
|
self.remote_url = self.cucchiaiata_config.remote_url
|
|
self.remote_config = self.remote_json_to_config()
|
|
|
|
# build a tiramisu parser and parse argument
|
|
parser = CucchiaiataParser(self.remote_config,
|
|
fullpath=False,
|
|
remove_empty_od=True,
|
|
display_modified_value=False,
|
|
formatter_class=RawDescriptionHelpFormatter)
|
|
parser.parse_args()
|
|
|
|
def get(self):
|
|
# get current message
|
|
message = self.remote_config.option('message').value.get()
|
|
payload = self.get_payload(message)
|
|
# send message
|
|
result = self.send_data(message,
|
|
payload)
|
|
|
|
# convert some results (file) to json
|
|
if message in TO_JSON:
|
|
if isinstance(result, list):
|
|
for res in result:
|
|
_to_json(res)
|
|
else:
|
|
_to_json(result)
|
|
|
|
return dumps(result, indent=config.indent)
|
|
|
|
def remote_json_to_config(self,
|
|
headers=None,
|
|
config_type=Config):
|
|
"retrieves the remote config from the distant api description"
|
|
req = get(self.remote_url,
|
|
headers=headers,
|
|
verify=False)
|
|
code = req.status_code
|
|
if code != 200:
|
|
err = get_error_from_http(req)
|
|
raise Exception('unable to load url ({}): {} ({})'.format(self.remote_url,
|
|
err,
|
|
code))
|
|
json = req.json()
|
|
return config_type(json)
|
|
|
|
def send_data(self,
|
|
message: str,
|
|
payload: Dict):
|
|
# get stored token if available
|
|
if isfile(self.cucchiaiata_config.token_file):
|
|
token = open(self.cucchiaiata_config.token_file).read()
|
|
else:
|
|
token = ''
|
|
final_url = '{}/{}'.format(self.remote_url, message)
|
|
headers = {'Authorization':'Bearer {}'.format(token)}
|
|
ret = post(final_url,
|
|
data=dumps(payload),
|
|
headers=headers,
|
|
# FIXME
|
|
verify=False)
|
|
if ret.status_code != 200:
|
|
raise Exception(ret.text)
|
|
response = ret.json()
|
|
if 'error' in response:
|
|
if 'reason' in response['error']['kwargs']:
|
|
raise Exception("{}".format(response['error']['kwargs']['reason']))
|
|
raise Exception('erreur inconnue')
|
|
else:
|
|
return(response['response'])
|
|
|
|
def _to_json(self, res):
|
|
for key, value in res.items():
|
|
if key in TO_JSON[message]:
|
|
res[key] = loads(value)
|
|
|
|
def get_payload(self,
|
|
message: str):
|
|
# remove symlinkoption and default value from payload
|
|
payload = {}
|
|
for option in self.remote_config.option(message).list():
|
|
if not option.owner.isdefault() and not option.option.issymlinkoption():
|
|
payload[option.option.name()] = option.value.get()
|
|
return payload
|
|
|
|
def get_error_from_http(self,
|
|
req):
|
|
try:
|
|
json = req.json()
|
|
err = json['error']['kwargs']['reason']
|
|
except:
|
|
err = req.text
|
|
return err
|
|
|
|
|
|
def configure_server(server, session_id, version, message, reporter=None):
|
|
url = 'https://{}/config/{}/api'.format(server, session_id)
|
|
token = open(config.token_file).read()
|
|
headers = {'Authorization':'Bearer {}'.format(token)}
|
|
tconfig = remote_json_to_config(url, headers, ConfigConfigurationAPI)
|
|
tconfig.version = version
|
|
tconfig.message = message
|
|
tconfig.url = server
|
|
tconfig.session_id = session_id
|
|
tconfig.reporter = reporter
|
|
return tconfig
|
|
|
|
|
|
|
|
def configuration(config,
|
|
session_id,
|
|
configure):
|
|
parameters = sys.argv.copy()
|
|
# get sessionid index session_id
|
|
try:
|
|
index = parameters.index('-s')
|
|
except ValueError:
|
|
try:
|
|
index = parameters.index('--sessionid')
|
|
except ValueError:
|
|
remote_config = remote_json_to_config(config.remote_url)
|
|
parser = cmdline_factory(remote_config)
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
parameters.pop(index)
|
|
session_id = parameters.pop(index)
|
|
# remove config.session.server.configure
|
|
parameters.pop(1)
|
|
# remove commandline
|
|
prog = parameters.pop(0)
|
|
try:
|
|
conf = configure_server(config.url,
|
|
session_id,
|
|
config.version,
|
|
configure)
|
|
parser = TiramisuCmdlineParser(conf,
|
|
prog,
|
|
unrestraint=True,
|
|
fullpath=True)
|
|
parser.parse_args(parameters,
|
|
valid_mandatory=False)
|
|
config.send()
|
|
except Exception as err:
|
|
if config.debug:
|
|
print_exc()
|
|
print(_("Error: {}").format(err))
|
|
sys.exit(1)
|