overflow_backup_2018_0455/overflow_service
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

discovery target end

Browse Source
This commit is contained in:
snoop 2017-06-27 16:52:32 +09:00
parent 8071b4bab0
commit 1e3fc868a7
4 changed files with 326 additions and 241 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

273
proxy/target/target_discovery_service.go Normal file
View File

@ -0,0 +1,273 @@
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"
)
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) {
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 "", 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
}

49
proxy/target/target_discovery_service_test.go Normal file
View File

@ -0,0 +1,49 @@
package target
import (
"git.loafle.net/overflow/overflow_service/proxy/probe"
"testing"
"git.loafle.net/overflow/overflow_service/proxy/infra"
"reflect"
"encoding/json"
"io/ioutil"
)
func TestTargetDiscovery(t *testing.T) {
contents,_ := ioutil.ReadFile("../../dh.json")
ti := TargetInfo{}
err := json.Unmarshal(contents, &ti)
if err != nil{
t.Fatal(err)
}
t.Log(ti)
ts := NewTargetService()
ppp := probe.Probe{}
ppp.Id = "1"
ti.Probe = &ppp
out, err := ts.RegistTarget(&ti)
if err != nil {
t.Fatal(err)
}
t.Log(out)
}
func TestInterface(t *testing.T) {
aaa := &infra.InfraMachine{}
var o interface{} = aaa
tt := reflect.TypeOf(o)
t.Log(tt.Name())
t.Log(tt.String())
}

203
proxy/target/target_service.go
View File

@ -3,12 +3,12 @@ package target
import ( import (
"encoding/json" "encoding/json"
"git.loafle.net/overflow/commons_go/model/timestamp" "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/infra"
"git.loafle.net/overflow/overflow_service/proxy/meta"
"git.loafle.net/overflow/overflow_service/proxy/probe" "git.loafle.net/overflow/overflow_service/proxy/probe"
"git.loafle.net/overflow/overflow_service/proxy/utils" "git.loafle.net/overflow/overflow_service/proxy/utils"
"strconv"
) )
@ -20,10 +20,7 @@ type Target struct {
Infra *infra.Infra `json:"infra,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 { type TargetService struct {
} }
@ -78,195 +75,3 @@ func (t *TargetService) Remove(target *Target) (string, error) {
return out, nil 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
}

42
proxy/target/target_service_test.go
View File

@ -7,9 +7,6 @@ import (
"git.loafle.net/overflow/overflow_service/proxy/probe" "git.loafle.net/overflow/overflow_service/proxy/probe"
"testing" "testing"
"io/ioutil"
"reflect"
) )
func TestTargetRegist(t *testing.T) { func TestTargetRegist(t *testing.T) {
@ -65,42 +62,3 @@ func TestTargetDelete(t *testing.T) {
} }
t.Log(res) t.Log(res)
} }
func TestTargetDiscovery(t *testing.T) {
contents,_ := ioutil.ReadFile("../../dh.json")
ti := TargetInfo{}
err := json.Unmarshal(contents, &ti)
if err != nil{
t.Fatal(err)
}
t.Log(ti)
ts := NewTargetService()
ppp := probe.Probe{}
ppp.Id = "1"
ti.Probe = &ppp
out, err := ts.RegistTarget(&ti)
if err != nil {
t.Fatal(err)
}
t.Log(out)
}
func TestInterface(t *testing.T) {
aaa := &infra.InfraMachine{}
var o interface{} = aaa
tt := reflect.TypeOf(o)
t.Log(tt.Name())
t.Log(tt.String())
}