lxd servers link parser.

lxd_link_parser.go

package main

import (
	"bufio"
	"bytes"
	"crypto/tls"
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"net/http"
	"net/url"
	"strings"
)

type image_server struct {
	Name            string              `json:"name"`
	Desc            string              `json:"description"`
	DescFr          string              `json:"description.fr"`
	Url             string              `json:"url"`
	Arguments       []map[string]string `json:"arguments"`
	TrustedKeys     []string            `json:"trusted_keys"`
	TrustedCerts    []string            `json:"trusted_certs"`
	MinClientVer    int                 `json:"min_client_ver"`
	MaxClientVer    int                 `json:"max_client_ver"`
	image_path_list map[string]string
}

type registry_server struct {
	Version         int            `json:"version"`
	GenAt           uint64         `json:"generated_at"`
	ImageServerList []image_server `json:"servers"`
}

type registry_manager struct {
	serverCount int
	client      *http.Client
	registry    registry_server
}

func main() {

	var rm registry_manager

	/*
		data, err := ioutil.ReadFile("./config.cfg")
		if err!=nil {
			fmt.Println(err)
		}
	*/

	// Test code goes here
	rm.init_registry_manager()
	err := rm.fetch_image_server_data()
	if err != nil {
		fmt.Println(err)
	}
	url, _, err := rm.get_image_server_url("lxc-images")
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(url)
	url_list, err := rm.get_image_servers()
	fmt.Println(url_list)

	rm.get_image_list("lxc-images")
	rm.get_image_server_path("lxc-images/ubuntu/vivid/arm64")

}

func (rm *registry_manager) init_registry_manager() {
	proxyUrl, err := url.Parse("http://172.26.0.75:8080")
	if err != nil {
		fmt.Println(err)
	}

	tr := &http.Transport{
		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
		Proxy:           http.ProxyURL(proxyUrl),
	}
	rm.client = &http.Client{Transport: tr}

}

func (rm *registry_manager) fetch_image_server_data() error {

	resp, err := rm.client.Get("https://registry.linuxcontainers.org/1.0/index.json")
	if err != nil {
		fmt.Println(err)
	}
	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)

	//NOTE: Need to allocate memory for 1, rest if present it will automatically appended
	// by Unmarshal function.
	servers := make([]image_server, 1)
	keyList := make([]string, 0)
	servers[0].TrustedKeys = keyList
	rm.registry.ImageServerList = servers

	err = json.Unmarshal(body, &rm.registry)
	if err != nil {
		//FIXME: Log this
		fmt.Println(err)
	}
	//	showConfig(rm.registry)
	return err

}

func (rm *registry_manager) get_image_servers() ([]string, error) {

	urlList := make([]string, 0)
	var err error

	for i := range rm.registry.ImageServerList {
		urlList = append(urlList, rm.registry.ImageServerList[i].Name)
	}
	return urlList, err
}

func (rm *registry_manager) get_image_server_url(server_name string) (string, int, error) {

	var url string
	var err error
	var i int
	//	showConfig(rm.registry)

	for i = range rm.registry.ImageServerList {
		if server_name == rm.registry.ImageServerList[i].Name {
			url, _ = getURL(rm.registry.ImageServerList[i].Url)
		}

	}
	if url == "" {
		err = errors.New("No such server found in list")
	}
	return url, i, err
}

func (rm *registry_manager) get_image_list(image_server string) (map[string]string, error) {

	image_server_list := make(map[string]string)
	url, index, err := rm.get_image_server_url(image_server)
	if err != nil {
		fmt.Println(err)
	}
	resp, err := rm.client.Get(url + "/meta/1.0/index-system")
	if err != nil {
		fmt.Println(err)
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	reader := bytes.NewReader(body)

	scanner := bufio.NewScanner(reader)
	for scanner.Scan() {
		tokens := getTokens(scanner.Text(), ";", 6)
		image_server_list[tokens[0]+"/"+tokens[1]+"/"+tokens[2]] = tokens[5]

	}
	if err := scanner.Err(); err != nil {
		fmt.Println(err)
	}
	//	fmt.Println(image_server_list)
	rm.registry.ImageServerList[index].image_path_list = image_server_list
	return image_server_list, err

}

func (rm *registry_manager) get_image_server_path(image_name string) (string, error) {
	image_server := getTokens(image_name, "/", 2)
	_, index, err := rm.get_image_server_url(image_server[0])
	if err != nil {
		fmt.Println(err)
	}

	fmt.Println(rm.registry.ImageServerList[index].image_path_list[image_server[1]])
	return rm.registry.ImageServerList[index].image_path_list[image_server[1]], err
}

func showConfig(config interface{}) {
	ra_json, _ := json.MarshalIndent(config, "", "  ")
	fmt.Println(string(ra_json))
}

func getURL(link string) (string, error) {
	var err error
	proto := strings.SplitN(link, "+", 2)
	if proto[1] == "" {
		err = errors.New("URL is not as expected")
	}
	uri := strings.SplitN(link, ":", 2)
	return proto[0] + ":" + uri[1], err
}

func getTokens(uri string, token string, count int) []string {
	result := strings.SplitN(uri, token, count)
	return result
}