cli chartmuseum

ccm.py

import requests
import argparse
import os.path
import json

HOST = "chartmuseum.dev"
PORT = "8080"
PATH = "api/charts"

def __get(**kwargs):
    
    # GET
    if kwargs['host'] and kwargs['port']:
        url = f"http://{kwargs['host']}:{kwargs['port']}/{PATH}"
    else:
        url = f"http://{HOST}:{PORT}/{PATH}"

    try:
        if kwargs['chart_name']:
            url = url + f"/{kwargs['chart_name']}"
            try:
                if kwargs['chart_version']:
                    url = url + f"/{kwargs['chart_version']}"
            except KeyError:
                pass
    except KeyError:
        print("not found chart name")
        exit(1)

    # HTTP
    try:
        req = requests.get(url)
    except requests.exceptions.ConnectionError as e:
        print(f"{e}")
        exit(1)

    # DATA
    data = req.json()
    dataloader = {}

    if type(data) == dict:
        try:
            if data['version'] not in dataloader:
                dataloader[data['version']] = {}
            for chart_key in data.keys():
                dataloader[data['version']][chart_key] = data[chart_key]
            show_dataloader(dataloader, **kwargs)
        except KeyError:
            print(f"{data}")
            exit(0)
    elif type(data) == list:
        try:
            if kwargs['latest']:
                dataloader[data[-0]['version']] = {}
                for chart_key in data[-0].keys():
                    dataloader[data[-0]['version']][chart_key] = data[-0][chart_key]
        except KeyError:
            for chart in data:
                dataloader[chart['version']] = {}
                for chart_key in chart.keys():
                    dataloader[chart['version']][chart_key] = chart[chart_key]
        except Exception as e:
            print(e)
        show_dataloader(dataloader, **kwargs)
    else:
        print(f"NOT FOUND DATALOADER {type(data)} - {data}")

def __list(**kwargs):

    # LIST
    if kwargs['host'] and kwargs['port']:
        url = f"http://{kwargs['host']}:{kwargs['port']}/{PATH}"
    else:
        url = f"http://{HOST}:{PORT}/{PATH}"

    # HTTP
    try:
        req = requests.get(url)
    except requests.exceptions.ConnectionError as e:
        print(f"{e}")
        exit(1)

    # DATA
    data = req.json()
    dataloader = {}
    if type(data) == dict:
        for chart in data.keys():
            for chart_properties in data[chart]:
                if chart_properties['version'] not in dataloader:
                    dataloader[chart_properties['version']] = {}
                for chart_key in chart_properties.keys():
                    dataloader[chart_properties['version']][chart_key] = chart_properties[chart_key]
        show_dataloader(dataloader, **kwargs)
    else:
        print(f"NOT FOUND DATALOADER {type(data)} - {data}")

def __push(**kwargs):
    
    # PUSH
    if kwargs['host'] and kwargs['port']:
        url = f"http://{kwargs['host']}:{kwargs['port']}/{PATH}"
    else:
        url = f"http://{HOST}:{PORT}/{PATH}"
    try:
        if kwargs['file']:
            if os.path.isfile(kwargs['file']):
                with open(os.path.abspath(kwargs["file"]), 'rb') as f:
                    file_read = f.read()
            else:
                print(f"File Not found {kwargs['file']}")
                exit(1)
    except KeyError:
        print("Failed Publicate Chart")
        exit(0)

    # HTTP
    try:
        req = requests.post(url, data=file_read)
    except requests.exceptions.ConnectionError as e:
        print(f"{e}")
        exit(1)

    # DATA
    data = req.json()
    data['http_code'] = req.status_code
    for data_key in data:
        print(f"{data_key.upper()}: {data[data_key]}")

def __pull(**kwargs):

    # PULL
    if kwargs['host'] and kwargs['port']:
        url = f"http://{kwargs['host']}:{kwargs['port']}/{PATH}"
    else:
        url = f"http://{HOST}:{PORT}/{PATH}"

    try:
        if kwargs['chart_name']:
            url = url + f"/{kwargs['chart_name']}"
            try:
                if kwargs['chart_version']:
                    url = url + f"/{kwargs['chart_version']}"
            except KeyError:
                print("not found chart version")
                exit(1)
    except KeyError:
        print("not found chart name")
        exit(1)

    # HTTP
    try:
        req = requests.get(url)
    except requests.exceptions.ConnectionError as e:
        print(f"{e}")
        exit(1)

    # DATA
    data = req.json()
    try:
        req = requests.get(f"http://{kwargs['host']}:{kwargs['port']}/{' '.join(data['urls'])}", allow_redirects=True)
        open(f"{kwargs['chart_name']}-{kwargs['chart_version']}.tgz", 'wb').write(req.content)
        data['HTTP_code'] = req.status_code
        data['file'] = f"{kwargs['chart_name']}-{kwargs['chart_version']}.tgz"
    except Exception as e:
        print(e)
        exit(1)

    for data_key in data:
        print(f"{data_key.upper()}: {data[data_key]}")

def __remove(**kwargs):
    
    # REMOVE
    if kwargs['host'] and kwargs['port']:
        url = f"http://{kwargs['host']}:{kwargs['port']}/{PATH}"
    else:
        url = f"http://{HOST}:{PORT}/{PATH}"
    try:
        if kwargs['chart_name']:
            url = url + f"/{kwargs['chart_name']}"
            try:
                if kwargs['chart_version']:
                    url = url + f"/{kwargs['chart_version']}"
            except KeyError:
                parser.print_help()
                print("\nERROR: not found chart_version")
                exit(1)
    except KeyError:
        parser.print_help()
        print("\nERROR: not found chart_name")
        exit(0)

    # HTTP
    try:
        req = requests.delete(url)
    except requests.exceptions.ConnectionError as e:
        print(f"{e}")
        exit(1)
    
    # DATA
    data = req.json()
    #print(r.request.url) #print(r.request.body) #print(r.request.headers)
    data['status_code'] = req.status_code
    for data_key in data:
        print(f"{data_key.upper()}: {data[data_key]}")

def show_dataloader(data, **kwargs):

    # OUTPUT
    if kwargs['output'] == "table":
        if kwargs['headers'] == True:
            print ("{:<8} {:<10} {:<15} {:<15} {:<8}".format('NAME','VERSION','APP_VERSION','TYPE', 'DESCRIPTION'))
        for chart in data.keys():
            print("{:<8} {:<10} {:<15} {:<15} {:<8}".format(data[chart]['name'], data[chart]['version'], data[chart]['appVersion'] , data[chart]['type'] , data[chart]['description'] ))
    else:
       print(json.dumps(data, indent=4))

def method(**kwargs):
    # Methods
    if kwargs['method'].upper() == "GET":
        __get(**kwargs)
    elif kwargs['method'].upper() == "PUSH":
        __push(**kwargs)
    elif kwargs['method'].upper() == "PULL":
        __pull(**kwargs)
    elif kwargs['method'].upper() == "REMOVE":
        __remove(**kwargs)
    elif kwargs['method'].upper() == "LIST":
        __list(**kwargs)
    else:
        print(f"Invalid Method: {kwargs['method']}")

def main(args):
    kwargs = {}
    # Data
    if args.method:
        kwargs['method'] = args.method
    if args.chart_name:
        kwargs['chart_name'] = args.chart_name
    if args.chart_version:
        kwargs['chart_version'] = args.chart_version
    if args.file:
       kwargs['file'] = args.file 
    if args.host:
        kwargs['host'] = args.host
    if args.port:
        kwargs['port'] = args.port
    if args.latest_chart_version:
        kwargs['latest'] = args.latest_chart_version
    # Output
    if args.output:
        kwargs['output'] = args.output
    # Debug
    #if args.debug:
    #    kwargs['debug'] = args.debug
    # Headers
    if args.headers:
        kwargs['headers'] = False
    else:
        kwargs['headers'] = True

    method(**kwargs)

def __formatter(prog):
        return argparse.HelpFormatter(prog, max_help_position=100, width=200)

if __name__ == "__main__":
    
    parser = argparse.ArgumentParser(prog='ccm.py', description='CLI ChartMuseum', formatter_class=__formatter)
    parser.add_argument("method", help='select method', choices=['list', 'get', 'push', 'pull', 'remove'])
    parser.add_argument("-c",'--chart', dest='chart_name', help='chart name', metavar="NAME",)
    parser.add_argument("-v",'--version', dest='chart_version', help='chart version', metavar="VERSION")
    parser.add_argument('--latest', default=False, action='store_true', dest='latest_chart_version', help="select latest version chart_name")
    parser.add_argument('--file', dest='file', help='file chart')
    parser.add_argument('--host', dest='host', help='server host')
    parser.add_argument('--port', dest='port', help='server port')
    parser.add_argument('--no-headers', dest='headers', help='not show headers', action='store_true')
    parser.add_argument("-o","--output", help='output format - [json , table]', dest='output', default="table" ,choices=['json','table'], metavar='TYPE')
    #parser.add_argument("-d",'--debug', default=False, action='store_true', dest='debug', help="mode debug")
    args = parser.parse_args()
    main(args)