overflow_service/proxy/target/target_service.go

package target

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


)

type Target struct {
	Id         json.Number         `json:"id,Number,omitempty"`
	CreateDate timestamp.Timestamp `json:"createDate,omitempty"`
	Probe      *probe.Probe        `json:"probe,omitempty"`
	Infra      *infra.Infra        `json:"infra,omitempty"`
}

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

type TargetService struct {
}

func NewTargetService() *TargetService {
	return &TargetService{}
}

func (t *TargetService) GetModel() interface{} {
	return &Target{}
}

func (t *TargetService) ReadAllByProbe(p *probe.Probe) (string, error) {

	out, err := utils.InvokeDBByModel("target", "findAllByProbe", p, utils.MODEL_PROBE)

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

	return out, err
}

func (t *TargetService) Regist(target *Target) (string, error) {
	out, err := utils.InvokeDBByModel("target", "save", target, utils.MODEL_TARGET)

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

	return out, nil
}

func (t *TargetService) Read(id string) (string, error) {

	out, err := utils.InvokeDBByModel("target", "findOne", id, utils.MODEL_LONG)

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

	return out, nil
}

func (t *TargetService) Remove(target *Target) (string, error) {

	out, err := utils.InvokeDBByModel("target", "delete", target, utils.MODEL_TARGET)

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

	return out, nil
}

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

	is := infra.NewInfraService()

	for _, host := range *ti.Hosts {

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

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

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

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

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

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

		out, err = is.RegistOS(&io)

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

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

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

		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 "", err
		}

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

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

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


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


		for _, port := range host.Ports {

			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 "", err
			}

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

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

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

			err = RegistTarget(port.Target, iip, ti.Probe)
			if err != nil {
				return "", err
			}

			for _, service := range port.Services {

				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 "", err
				}

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

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

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

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

			}

		}

	}

	return "", 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
}