overflow_service/proxy/target/target_discovery_service.go

package target

import (
	"git.loafle.net/overflow/overflow_service/proxy/infra"
	"git.loafle.net/overflow/overflow_service/proxy/probe"
	"encoding/json"
	"git.loafle.net/overflow/overflow_service/proxy/meta"
	"strconv"
	"git.loafle.net/overflow/discovery/discovery/types"

	"git.loafle.net/overflow/overflow_service/proxy"
	"git.loafle.net/overflow/overflow_service/proxy/utils"
)

type TargetInfo struct {
	Hosts *[]*types.DiscoveryHost `json:"hosts,omitempty"`
	Probe *probe.Probe            `json:"probe,omitempty"`
}

func registInfraMachine(host * types.DiscoveryHost, p * probe.Probe) (*infra.InfraMachine, error) {

	is := infra.NewInfraService()

	im := infra.InfraMachine{}
	im.Probe = p

	out, err := is.RegistMachine(&im)

	if err != nil {
		return nil, err
	}

	err = json.Unmarshal([]byte(out), &im)
	if err != nil {
		return nil, err
	}

	iim := infra.NewInfra(im.Id, &im)
	_, err = is.Regist(iim)
	if err != nil {
		return nil, err
	}

	return &im, nil

}

func registInfraOS(im *infra.InfraMachine, os string) (*infra.InfraOS, error) {

	is := infra.NewInfraService()

	io := infra.InfraOS{}
	io.InfraMachine = im
	miv := meta.MetaInfraVendor{}
	if os == "Windows" {
		miv.Id = "25"
	} else if os == "Linux" {
		miv.Id = "27"
	}
	io.MetaInfraVendor = &miv

	out, err := is.RegistOS(&io)

	if err != nil {
		return nil, err
	}

	err = json.Unmarshal([]byte(out), &io)
	if err != nil {
		return nil, err
	}

	iio := infra.NewInfra(io.Id, &io)
	_, err = is.Regist(iio)
	if err != nil {
		return nil, err
	}

	return &io, nil

}

func registInfraHost(host *types.DiscoveryHost, io *infra.InfraOS, p *probe.Probe ) (*infra.InfraHost, error) {

	is := infra.NewInfraService()

	ih := infra.InfraHost{}
	ih.InfraOS = io
	ih.Ip = json.Number(strconv.FormatInt(host.Ip, 10))
	ih.Mac = json.Number(strconv.FormatInt(host.Mac, 10))

	out, err := is.RegistHost(&ih)

	if err != nil {
		return nil, err
	}

	err = json.Unmarshal([]byte(out), &ih)
	if err != nil {
		return nil, err
	}

	iih := infra.NewInfra(ih.Id, &ih)
	out, err = is.Regist(iih)
	if err != nil {
		return nil, err
	}

	err = json.Unmarshal([]byte(out), iih)
	if err != nil {
		return nil, err
	}


	err = RegistTarget(host.Target, iih, p)
	if err != nil {
		return nil, err
	}

	return &ih, nil
}

func registInfraPort(port *types.DiscoveryPort, io *infra.InfraOS, p *probe.Probe) (*infra.InfraOSPort, error) {

	is := infra.NewInfraService()

	ip := infra.InfraOSPort{}
	ip.InfraOS = io
	ip.Port = json.Number(strconv.FormatUint(uint64(port.Number), 10))
	ip.PortType = port.PortType
	//ip.MetaInfraVendor
	//ip.TlsType

	out, err := is.RegistOSPort(&ip)

	if err != nil {
		return nil, err
	}

	err = json.Unmarshal([]byte(out), &ip)
	if err != nil {
		return nil, err
	}

	iip := infra.NewInfra(ip.Id, &ip)
	out, err = is.Regist(iip)
	if err != nil {
		return nil, err
	}

	err = json.Unmarshal([]byte(out), iip)
	if err != nil {
		return nil, err
	}

	//err = RegistTarget(port.Target, iip, p)
	//if err != nil {
	//	return nil, err
	//}

	return &ip, nil
}

func registInfraService(ih *infra.InfraHost, port *types.DiscoveryPort, service *types.DiscoveryService, p *probe.Probe) (*infra.InfraServiceApplication, error) {

	is := infra.NewInfraService()

	isa := infra.InfraServiceApplication{}

	isa.InfraHost = ih
	isa.PortType = port.PortType
	//isa.TlsType
	isa.Port = json.Number(strconv.FormatUint(uint64(port.Number), 10))
	//isa.MetaInfraVendor
	isa.MetaInfraVendor = meta.NewMetaInfraVendorByService(service.ServiceName)

	out, err := is.RegistService(&isa)

	if err != nil {
		return nil, err
	}

	err = json.Unmarshal([]byte(out), &isa)
	if err != nil {
		return nil, err
	}

	iisa := infra.NewInfra(isa.Id, &isa)
	out, err = is.Regist(iisa)
	if err != nil {
		return nil, err
	}

	err = json.Unmarshal([]byte(out), iisa)
	if err != nil {
		return nil, err
	}

	err = RegistTarget(service.Target, iisa, p)
	if err != nil {
		return nil, err
	}

	return &isa, nil
}

//FIXME:  Discovery Result
func (t *TargetService) RegistTarget(ti *TargetInfo) (string, error) {

	//serviceTarget

	m := make(map[string]string)

	hBy, err := json.Marshal(ti.Hosts)
	if err != nil {
		return "", err
	}

	pBy, err := json.Marshal(ti.Probe)
	if err != nil {
		return "", err
	}

	m[utils.MODEL_PROBE] = string(pBy)

	hostListStr := utils.MODEL_LIST
	hostListStr += "|"
	hostListStr += utils.MODEL_HOST

	m[hostListStr] = string(hBy)

	out, err := proxy.InvokeDB("serviceTarget", "saveAllTarget", m)

	if err != nil {
		return "",err
	}


	//for _, host := range *ti.Hosts {
	//
	//	im, err := registInfraMachine(host, ti.Probe)
	//
	//	if err != nil {
	//		return "", err
	//	}
	//
	//	io, err := registInfraOS(im, host.Os)
	//
	//	if err != nil {
	//		return "", err
	//	}
	//
	//	ih, err := registInfraHost(host, io, ti.Probe)
	//
	//	if err != nil {
	//		return "", err
	//	}
	//
	//	for _, port := range host.Ports {
	//
	//		_, err := registInfraPort(port, io, ti.Probe)
	//
	//		if err != nil {
	//			return "", err
	//		}
	//
	//		for _, service := range port.Services {
	//
	//			_, err := registInfraService(ih, port, service, ti.Probe)
	//
	//			if err != nil {
	//				return "", err
	//			}
	//		}
	//
	//	}
	//
	//}

	return out, nil
}


func RegistTarget(check bool, i *infra.Infra, p *probe.Probe) error {

	if check == false {
		return nil
	}

	ttt := &Target{}
	ttt.Infra = i
	ttt.Probe = p

	ts := NewTargetService()
	_, err := ts.Regist(ttt)

	if err != nil {
		return err
	}

	return nil
}