overflow_cloud/container_discovery
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ing

Browse Source
This commit is contained in:
crusader 2018-06-13 19:20:14 +09:00
parent 2345777e47
commit c65fd4ab7d
14 changed files with 128 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Gopkg.lock generated
View File

@ -87,6 +87,7 @@
packages = [
"context",
"encoding/json",
"net",
"net/cidr",
"net/converter",
"reflect",
@ -95,7 +96,7 @@
"time/scheduler/storage",
"time/scheduler/task"
]
revision = "1966a985759721fd451171a78a0b8f4524afc644"
revision = "4d4017d214d2a8fdde59d774254f421991fabe7e"
[[projects]]
branch = "master"
@ -110,11 +111,12 @@
"core/util",
"model/data",
"model/discovery",
"model/meta",
"model/sensorconfig",
"service/container/discovery",
"service/probe"
]
revision = "078a39712d33c131303cf2705cca185da18cc196"
revision = "846c510a1ae54597ef1b1589613dfca7a3f7a3ed"
[[projects]]
branch = "master"
@ -213,6 +215,6 @@
[solve-meta]
analyzer-name = "dep"
analyzer-version = 1
inputs-digest = "1b6a1dbfca3cfb6cedd6a61fa2e3aac45cae3541a95ea40766264b926a64dd24"
inputs-digest = "70618d25eb22451d93f8eb5b0d9a744c3cdc9a8cb83089e70c19f8d4fcff959c"
solver-name = "gps-cdcl"
solver-version = 1

8
internal/discoverer/discoverer.go
View File

@ -154,10 +154,12 @@ func (d *defaultDiscoverer) innerDiscoverZone(wg *sync.WaitGroup, dataChan chan
if nil != dz.DiscoverHost {
cr, _ := cidr.NewCIDRRanger(z.Network)
dh := &ocmd.DiscoverHost{
FirstScanRangeV4: cr.First().String(),
LastScanRangeV4: cr.Last().String(),
DiscoverPort: dz.DiscoverHost.DiscoverPort,
MetaIPType: z.MetaIPType,
FirstScanRange: cr.First().String(),
LastScanRange: cr.Last().String(),
DiscoverPort: dz.DiscoverHost.DiscoverPort,
}
wg.Add(1)
go d.innerDiscoverHost(wg, dataChan, z, dh)
}

18
internal/discoverer/host.go
View File

@ -2,9 +2,9 @@ package discoverer
import (
"fmt"
"net"
ocmd "git.loafle.net/overflow/commons-go/model/discovery"
ocmm "git.loafle.net/overflow/commons-go/model/meta"
"git.loafle.net/overflow/container_discovery/internal/discoverer/ipv4"
"git.loafle.net/overflow/container_discovery/internal/discoverer/ipv6"
)
@ -14,19 +14,13 @@ func scanHost(zone *ocmd.Zone, dh *ocmd.DiscoverHost, resultChan chan interface{
doneChan <- struct{}{}
}()
_, ipNet, err := net.ParseCIDR(zone.Network)
if nil != err {
errChan <- err
return
}
switch len(ipNet.IP) {
case net.IPv4len:
switch ocmm.ToMetaIPTypeEnum(dh.MetaIPType) {
case ocmm.MetaIPTypeEnumV4:
ipv4.ScanHost(zone, dh, resultChan, errChan, stopChan)
case net.IPv6len:
case ocmm.MetaIPTypeEnumV6:
ipv6.ScanHost(zone, dh, resultChan, errChan, stopChan)
default:
errChan <- fmt.Errorf("Discovery: Not supported ip length")
return
errChan <- fmt.Errorf("Discovery: Not supported MetaIPType")
}
}

19
internal/discoverer/ipv4/host.go
View File

@ -86,7 +86,6 @@ func ScanHost(zone *ocmd.Zone, dh *ocmd.DiscoverHost, resultChan chan interface{
case <-timerStopped:
return
}
}
func sendARP(ps pcap.PCapScanner, zone *ocmd.Zone, hostRanges []net.IP, stopChan chan struct{}) error {
@ -94,9 +93,9 @@ func sendARP(ps pcap.PCapScanner, zone *ocmd.Zone, hostRanges []net.IP, stopChan
if nil != err {
return err
}
ip := net.ParseIP(zone.IPV4)
ip := net.ParseIP(zone.Address)
if nil == ip {
return fmt.Errorf("Discovery: IP(%s) of zone is not valid", zone.IPV4)
return fmt.Errorf("Discovery: IP(%s) of zone is not valid", zone.Address)
}
ethPacket := makePacketEthernet(hwAddr)
@ -146,7 +145,7 @@ func handlePacketARP(zone *ocmd.Zone, hostRanges []net.IP, hosts map[string]*ocm
}
h := &ocmd.Host{
IPV4: ip.String(),
Address: ip.String(),
Mac: net.HardwareAddr(packet.SourceHwAddress).String(),
Zone: zone,
DiscoveredDate: occu.NowPtr(),
@ -159,22 +158,22 @@ func handlePacketARP(zone *ocmd.Zone, hostRanges []net.IP, hosts map[string]*ocm
func getTargetHostRange(dh *ocmd.DiscoverHost, cr cidr.CIDRRanger) ([]net.IP, error) {
var firstIP net.IP
if "" != dh.FirstScanRangeV4 {
firstIP = net.ParseIP(dh.FirstScanRangeV4)
if "" != dh.FirstScanRange {
firstIP = net.ParseIP(dh.FirstScanRange)
if nil == firstIP {
return nil, fmt.Errorf("Discovery: IP(%v) of FirstScanRange host is not valid", firstIP)
}
}
var lastIP net.IP
if "" != dh.LastScanRangeV4 {
lastIP = net.ParseIP(dh.LastScanRangeV4)
if "" != dh.LastScanRange {
lastIP = net.ParseIP(dh.LastScanRange)
if nil == lastIP {
return nil, fmt.Errorf("Discovery: IP(%v) of LastScanRange host is not valid", lastIP)
}
}
includeIPs := make([]net.IP, 0)
for _, iHost := range dh.IncludeHostsV4 {
for _, iHost := range dh.IncludeHosts {
iIP := net.ParseIP(iHost)
if nil == iIP {
return nil, fmt.Errorf("Discovery: IP(%v) of include host is not valid", iHost)
@ -183,7 +182,7 @@ func getTargetHostRange(dh *ocmd.DiscoverHost, cr cidr.CIDRRanger) ([]net.IP, er
}
excludeIPs := make([]net.IP, 0)
for _, eHost := range dh.ExcludeHostsV4 {
for _, eHost := range dh.ExcludeHosts {
eIP := net.ParseIP(eHost)
if nil == eIP {
return nil, fmt.Errorf("Discovery: IP(%v) of exclude host is not valid", eHost)

18
internal/discoverer/ipv4/port_tcp.go
View File

@ -10,9 +10,9 @@ import (
"time"
"git.loafle.net/commons/logging-go"
occc "git.loafle.net/overflow/commons-go/core/constants"
occu "git.loafle.net/overflow/commons-go/core/util"
ocmd "git.loafle.net/overflow/commons-go/model/discovery"
ocmm "git.loafle.net/overflow/commons-go/model/meta"
"git.loafle.net/overflow/container_discovery/internal/pcap"
"github.com/google/gopacket"
@ -33,9 +33,9 @@ func scanPortTCP(host *ocmd.Host, dp *ocmd.DiscoverPort, resultChan chan interfa
go pcap.ReleaseScanner(host.Zone)
}()
tcpChan := ps.OpenTCP(host.IPV4)
tcpChan := ps.OpenTCP(host.Address)
defer func() {
go ps.CloseTCP(host.IPV4, tcpChan)
go ps.CloseTCP(host.Address, tcpChan)
}()
timerStopped := make(chan struct{})
@ -134,14 +134,14 @@ func handlePacketTCP(host *ocmd.Host, dp *ocmd.DiscoverPort, ports map[int]*ocmd
}
port := int(packet.SrcPort)
logging.Logger().Debugf("Discovery: IP of TCP(%d) src %s", port, host.IPV4)
logging.Logger().Debugf("Discovery: IP of TCP(%d) src %s", port, host.Address)
if _, ok := ports[port]; ok || !dp.Contains(port) {
return nil
}
p := &ocmd.Port{
PortType: occc.PortTypeTCP,
MetaPortType: ocmm.ToMetaPortType(ocmm.MetaPortTypeEnumTCP),
PortNumber: json.Number(strconv.Itoa(port)),
DiscoveredDate: occu.NowPtr(),
}
@ -162,13 +162,13 @@ type PortPacketTCP struct {
func makePacketPortTCP(host *ocmd.Host) (*PortPacketTCP, error) {
packetTCP := &PortPacketTCP{}
srcIP := net.ParseIP(host.Zone.IPV4)
srcIP := net.ParseIP(host.Zone.Address)
if nil == srcIP {
return nil, fmt.Errorf("Discovery: IP(%s) of zone is not valid", host.Zone.IPV4)
return nil, fmt.Errorf("Discovery: IP(%s) of zone is not valid", host.Zone.Address)
}
dstIP := net.ParseIP(host.IPV4)
dstIP := net.ParseIP(host.Address)
if nil == dstIP {
return nil, fmt.Errorf("Discovery: IP(%s) of host is not valid", host.IPV4)
return nil, fmt.Errorf("Discovery: IP(%s) of host is not valid", host.Address)
}
packetTCP.IP = &layers.IPv4{

14
internal/discoverer/ipv4/port_udp.go
View File

@ -10,9 +10,9 @@ import (
"time"
"git.loafle.net/commons/logging-go"
occc "git.loafle.net/overflow/commons-go/core/constants"
occu "git.loafle.net/overflow/commons-go/core/util"
ocmd "git.loafle.net/overflow/commons-go/model/discovery"
ocmm "git.loafle.net/overflow/commons-go/model/meta"
"git.loafle.net/overflow/container_discovery/internal/pcap"
"git.loafle.net/overflow/container_discovery/internal/matcher"
@ -34,9 +34,9 @@ func scanPortUDP(host *ocmd.Host, dp *ocmd.DiscoverPort, resultChan chan interfa
pcap.ReleaseScanner(host.Zone)
}()
udpChan := ps.OpenUDP(host.IPV4)
udpChan := ps.OpenUDP(host.Address)
defer func() {
ps.CloseUDP(host.IPV4, udpChan)
ps.CloseUDP(host.Address, udpChan)
}()
timerStopped := make(chan struct{})
@ -85,9 +85,9 @@ func scanPortUDP(host *ocmd.Host, dp *ocmd.DiscoverPort, resultChan chan interfa
}
func sendUDP(host *ocmd.Host, dp *ocmd.DiscoverPort, stopChan chan struct{}) error {
ip := net.ParseIP(host.IPV4)
ip := net.ParseIP(host.Address)
if nil == ip {
return fmt.Errorf("Discovery: IP(%s) of host is not valid", host.IPV4)
return fmt.Errorf("Discovery: IP(%s) of host is not valid", host.Address)
}
ms := matcher.GetUDPMatchers()
@ -141,7 +141,7 @@ func sendUDP(host *ocmd.Host, dp *ocmd.DiscoverPort, stopChan chan struct{}) err
func handlePacketUDP(host *ocmd.Host, dp *ocmd.DiscoverPort, ports map[int]*ocmd.Port, packet gopacket.Packet) *ocmd.Port {
ipLayer := packet.Layer(layers.LayerTypeIPv4)
if ipLayer.(*layers.IPv4).SrcIP.String() == host.Zone.IPV4 {
if ipLayer.(*layers.IPv4).SrcIP.String() == host.Zone.Address {
return nil
}
@ -157,7 +157,7 @@ func handlePacketUDP(host *ocmd.Host, dp *ocmd.DiscoverPort, ports map[int]*ocmd
}
p := &ocmd.Port{
PortType: occc.PortTypeUDP,
MetaPortType: ocmm.ToMetaPortType(ocmm.MetaPortTypeEnumUDP),
PortNumber: json.Number(strconv.Itoa(port)),
UDPLayer: udpLayer,
DiscoveredDate: occu.NowPtr(),

13
internal/discoverer/ipv4/service.go
View File

@ -4,9 +4,9 @@ import (
"fmt"
cuej "git.loafle.net/commons/util-go/encoding/json"
occc "git.loafle.net/overflow/commons-go/core/constants"
occu "git.loafle.net/overflow/commons-go/core/util"
ocmd "git.loafle.net/overflow/commons-go/model/discovery"
ocmm "git.loafle.net/overflow/commons-go/model/meta"
"github.com/google/gopacket/layers"
)
@ -17,14 +17,13 @@ func ScanService(port *ocmd.Port, ds *ocmd.DiscoverService, resultChan chan inte
return
}
switch port.PortType {
case occc.PortTypeTCP:
switch ocmm.ToMetaPortTypeEnum(port.MetaPortType) {
case ocmm.MetaPortTypeEnumTCP:
if !scanServiceTCP(port, ds, resultChan, errChan, stopChan) {
if dName, ok := layers.TCPPortNames[layers.TCPPort(portNumber)]; ok {
sName := fmt.Sprintf("Not Supported Service. Perhaps %s[%d]", dName, portNumber)
s := &ocmd.Service{
ServiceName: sName,
Name: sName,
DiscoveredDate: occu.NowPtr(),
Port: port,
}
@ -32,12 +31,12 @@ func ScanService(port *ocmd.Port, ds *ocmd.DiscoverService, resultChan chan inte
}
}
case occc.PortTypeUDP:
case ocmm.MetaPortTypeEnumUDP:
if !scanServiceUDP(port, ds, resultChan, errChan, stopChan) {
if dName, ok := layers.UDPPortNames[layers.UDPPort(portNumber)]; ok {
sName := fmt.Sprintf("Not Supported Service. Perhaps %s[%d]", dName, portNumber)
s := &ocmd.Service{
ServiceName: sName,
Name: sName,
DiscoveredDate: occu.NowPtr(),
Port: port,
}

16
internal/discoverer/ipv4/service_conn.go
View File

@ -5,19 +5,21 @@ import (
"fmt"
"net"
"time"
ocmm "git.loafle.net/overflow/commons-go/model/meta"
)
type serviceConnector interface {
CryptoType() string
MetaCryptoType() *ocmm.MetaCryptoType
Dial(ip string, port int) (net.Conn, error)
}
type normalServiceConn struct {
cryptoType string
metaCryptoType *ocmm.MetaCryptoType
}
func (nsc *normalServiceConn) CryptoType() string {
return nsc.cryptoType
func (nsc *normalServiceConn) MetaCryptoType() *ocmm.MetaCryptoType {
return nsc.metaCryptoType
}
func (nsc *normalServiceConn) Dial(ip string, port int) (net.Conn, error) {
@ -31,11 +33,11 @@ func (nsc *normalServiceConn) Dial(ip string, port int) (net.Conn, error) {
}
type tlsServiceConn struct {
cryptoType string
metaCryptoType *ocmm.MetaCryptoType
}
func (tsc *tlsServiceConn) CryptoType() string {
return tsc.cryptoType
func (tsc *tlsServiceConn) MetaCryptoType() *ocmm.MetaCryptoType {
return tsc.metaCryptoType
}
func (tsc *tlsServiceConn) Dial(ip string, port int) (net.Conn, error) {

74
internal/discoverer/ipv4/service_tcp.go
View File

@ -8,14 +8,14 @@ import (
"git.loafle.net/commons/logging-go"
csm "git.loafle.net/commons/service_matcher-go"
cuej "git.loafle.net/commons/util-go/encoding/json"
occc "git.loafle.net/overflow/commons-go/core/constants"
occu "git.loafle.net/overflow/commons-go/core/util"
ocmd "git.loafle.net/overflow/commons-go/model/discovery"
ocmm "git.loafle.net/overflow/commons-go/model/meta"
"git.loafle.net/overflow/container_discovery/internal/matcher"
)
func scanServiceTCP(port *ocmd.Port, ds *ocmd.DiscoverService, resultChan chan interface{}, errChan chan error, stopChan chan struct{}) bool {
hostIP := port.Host.IPV4
hostIP := port.Host.Address
portNumber, err := cuej.NumberToInt(port.PortNumber)
if err != nil {
errChan <- fmt.Errorf("Discovery: Service scan on %s:%s error has occurred %v ", hostIP, port.PortNumber, err)
@ -27,10 +27,10 @@ func scanServiceTCP(port *ocmd.Port, ds *ocmd.DiscoverService, resultChan chan i
scs := []serviceConnector{
&normalServiceConn{
cryptoType: occc.CryptoTypeNONE.String(),
metaCryptoType: ocmm.ToMetaCryptoType(ocmm.MetaCryptoTypeEnumNONE),
},
&tlsServiceConn{
cryptoType: occc.CryptoTypeTLS.String(),
metaCryptoType: ocmm.ToMetaCryptoType(ocmm.MetaCryptoTypeEnumTLS),
},
}
@ -40,15 +40,15 @@ LOOP:
conn, err := sc.Dial(hostIP, portNumber)
if err != nil {
errChan <- fmt.Errorf("Discovery: Service scan[%s] on %s:%d error has occurred %v ", sc.CryptoType(), hostIP, portNumber, err)
errChan <- fmt.Errorf("Discovery: Service scan[%s] on %s:%d error has occurred %v ", sc.MetaCryptoType().Key, hostIP, portNumber, err)
return false
}
logging.Logger().Debugf("Discovery: Service scan connected[%s:%d] %s", hostIP, portNumber, sc.CryptoType())
logging.Logger().Debugf("Discovery: Service scan connected[%s:%d] %s", hostIP, portNumber, sc.MetaCryptoType().Key)
buf := make([]byte, 1024)
if err := conn.SetReadDeadline(time.Now().Add(1 * time.Second)); nil != err {
logging.Logger().Debugf("Discovery: cannot set readdeadline connected[%s:%d] %s", hostIP, portNumber, sc.CryptoType())
logging.Logger().Debugf("Discovery: cannot set readdeadline connected[%s:%d] %s", hostIP, portNumber, sc.MetaCryptoType().Key)
return false
}
rn, err := conn.Read(buf)
@ -88,7 +88,7 @@ func hadlePrePacket(info csm.MatchInfo, sc serviceConnector, conn net.Conn, pack
}()
// logging.Logger().Debugf("Discovery: Service scan pre packet length[%d], buf[%v]", packet.Len, packet.Buffer)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d pre packet length[%d]", sc.CryptoType(), info.IP(), info.Port(), packet.Len)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d pre packet length[%d]", sc.MetaCryptoType().Key, info.IP(), info.Port(), packet.Len)
ms := matcher.GetTCPMatchers(true)
buf := make([]byte, 1024)
@ -103,9 +103,9 @@ LOOP:
if 0 == packetCount {
s = &ocmd.Service{
ServiceName: m.Name(),
CryptoType: occc.ToCryptoType(sc.CryptoType()),
DiscoveredDate: occu.NowPtr(),
Name: m.Name(),
MetaCryptoTypeKey: sc.MetaCryptoType(),
DiscoveredDate: occu.NowPtr(),
}
break LOOP
}
@ -115,39 +115,39 @@ LOOP:
for j := 0; j < packetCount; j++ {
tPacket := m.Packet(j)
// logging.Logger().Debugf("Discovery: Service scan send packet length[%d], buf[%v]", tPacket.Len, tPacket.Buffer)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d send packet length[%d]", sc.CryptoType(), info.IP(), info.Port(), tPacket.Len)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d send packet length[%d]", sc.MetaCryptoType().Key, info.IP(), info.Port(), tPacket.Len)
if err := conn.SetWriteDeadline(time.Now().Add(1 * time.Second)); nil != err {
logging.Logger().Debugf("Discovery: cannot set writeDeadLine Service scan[%s] on %s:%d send packet length[%d]", sc.CryptoType(), info.IP(), info.Port(), tPacket.Len)
logging.Logger().Debugf("Discovery: cannot set writeDeadLine Service scan[%s] on %s:%d send packet length[%d]", sc.MetaCryptoType().Key, info.IP(), info.Port(), tPacket.Len)
break LOOP
}
wn, err := conn.Write(tPacket.Buffer)
if nil != err {
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d send packet error %v", sc.CryptoType(), info.IP(), info.Port(), err)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d send packet error %v", sc.MetaCryptoType().Key, info.IP(), info.Port(), err)
continue LOOP
}
if wn != tPacket.Len {
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d send packet length[%d] not same with %d", sc.CryptoType(), info.IP(), info.Port(), wn, tPacket.Len)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d send packet length[%d] not same with %d", sc.MetaCryptoType().Key, info.IP(), info.Port(), wn, tPacket.Len)
continue LOOP
}
if err := conn.SetReadDeadline(time.Now().Add(1 * time.Second)); nil != err {
logging.Logger().Debugf("Discovery: cannot set readDeadLine Service scan[%s] on %s:%d send packet length[%d]", sc.CryptoType(), info.IP(), info.Port(), tPacket.Len)
logging.Logger().Debugf("Discovery: cannot set readDeadLine Service scan[%s] on %s:%d send packet length[%d]", sc.MetaCryptoType().Key, info.IP(), info.Port(), tPacket.Len)
break LOOP
}
rn, err := conn.Read(buf)
if nil != err {
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d receive packet error %v", sc.CryptoType(), info.IP(), info.Port(), err)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d receive packet error %v", sc.MetaCryptoType().Key, info.IP(), info.Port(), err)
break LOOP
}
if m.Match(info, j+1, csm.NewPacket(buf, rn)) {
// logging.Logger().Debugf("Discovery: Service scan receive match length[%d], buf[%v]", rn, buf)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d receive match length[%d]", sc.CryptoType(), info.IP(), info.Port(), rn)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d receive match length[%d]", sc.MetaCryptoType().Key, info.IP(), info.Port(), rn)
found = true
} else {
// logging.Logger().Debugf("Discovery: Service scan receive not match length[%d], buf[%v]", rn, buf)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d receive not match length[%d]", sc.CryptoType(), info.IP(), info.Port(), rn)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d receive not match length[%d]", sc.MetaCryptoType().Key, info.IP(), info.Port(), rn)
found = false
continue LOOP
}
@ -155,9 +155,9 @@ LOOP:
if found {
s = &ocmd.Service{
ServiceName: m.Name(),
CryptoType: occc.ToCryptoType(sc.CryptoType()),
DiscoveredDate: occu.NowPtr(),
Name: m.Name(),
MetaCryptoTypeKey: sc.MetaCryptoType(),
DiscoveredDate: occu.NowPtr(),
}
break LOOP
}
@ -181,7 +181,7 @@ LOOP:
conn, err := sc.Dial(info.IP(), info.Port())
if err != nil {
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d socket dial error %v", sc.CryptoType(), info.IP(), info.Port(), err)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d socket dial error %v", sc.MetaCryptoType().Key, info.IP(), info.Port(), err)
break LOOP
}
@ -189,57 +189,57 @@ LOOP:
for j := 0; j < packetCount; j++ {
tPacket := m.Packet(j)
// logging.Logger().Debugf("Discovery: Service scan send packet length[%d], buf[%v]", tPacket.Len, tPacket.Buffer)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d send packet length[%d]", sc.CryptoType(), info.IP(), info.Port(), tPacket.Len)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d send packet length[%d]", sc.MetaCryptoType().Key, info.IP(), info.Port(), tPacket.Len)
if err := conn.SetWriteDeadline(time.Now().Add(1 * time.Second)); nil != err {
logging.Logger().Debugf("Discovery: cannot set writeDeadLine Service scan[%s] on %s:%d send packet length[%d]", sc.CryptoType(), info.IP(), info.Port(), tPacket.Len)
logging.Logger().Debugf("Discovery: cannot set writeDeadLine Service scan[%s] on %s:%d send packet length[%d]", sc.MetaCryptoType().Key, info.IP(), info.Port(), tPacket.Len)
break
}
wn, err := conn.Write(tPacket.Buffer)
if nil != err {
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d send packet error %v", sc.CryptoType(), info.IP(), info.Port(), err)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d send packet error %v", sc.MetaCryptoType().Key, info.IP(), info.Port(), err)
break
}
if wn != tPacket.Len {
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d send packet length[%d] not same with %d", sc.CryptoType(), info.IP(), info.Port(), wn, tPacket.Len)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d send packet length[%d] not same with %d", sc.MetaCryptoType().Key, info.IP(), info.Port(), wn, tPacket.Len)
break
}
if err := conn.SetReadDeadline(time.Now().Add(1 * time.Second)); nil != err {
logging.Logger().Debugf("Discovery: cannot set readDeadLine Service scan[%s] on %s:%d send packet length[%d]", sc.CryptoType(), info.IP(), info.Port(), tPacket.Len)
logging.Logger().Debugf("Discovery: cannot set readDeadLine Service scan[%s] on %s:%d send packet length[%d]", sc.MetaCryptoType().Key, info.IP(), info.Port(), tPacket.Len)
break
}
rn, err := conn.Read(buf)
if nil != err {
if !m.HasResponse(j) {
s = &ocmd.Service{
ServiceName: m.Name(),
CryptoType: occc.ToCryptoType(sc.CryptoType()),
DiscoveredDate: occu.NowPtr(),
Name: m.Name(),
MetaCryptoTypeKey: sc.MetaCryptoType(),
DiscoveredDate: occu.NowPtr(),
}
break
}
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d receive packet error %v", sc.CryptoType(), info.IP(), info.Port(), err)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d receive packet error %v", sc.MetaCryptoType().Key, info.IP(), info.Port(), err)
break
}
if m.Match(info, j, csm.NewPacket(buf, rn)) {
if packetCount-1 == j {
s = &ocmd.Service{
ServiceName: m.Name(),
CryptoType: occc.ToCryptoType(sc.CryptoType()),
DiscoveredDate: occu.NowPtr(),
Name: m.Name(),
MetaCryptoTypeKey: sc.MetaCryptoType(),
DiscoveredDate: occu.NowPtr(),
}
break
}
// logging.Logger().Debugf("Discovery: Service scan receive match length[%d], buf[%v]", rn, buf)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d receive match length[%d]", sc.CryptoType(), info.IP(), info.Port(), rn)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d receive match length[%d]", sc.MetaCryptoType().Key, info.IP(), info.Port(), rn)
continue
} else {
// logging.Logger().Debugf("Discovery: Service scan receive not match length[%d], buf[%v]", rn, buf)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d receive not match length[%d]", sc.CryptoType(), info.IP(), info.Port(), rn)
logging.Logger().Debugf("Discovery: Service scan[%s] on %s:%d receive not match length[%d]", sc.MetaCryptoType().Key, info.IP(), info.Port(), rn)
break
}
}

4
internal/discoverer/ipv4/service_udp.go
View File

@ -18,7 +18,7 @@ func scanServiceUDP(port *ocmd.Port, ds *ocmd.DiscoverService, resultChan chan i
}
ms := matcher.GetUDPMatchers()
mi := csm.NewMatchInfo(port.Host.IPV4, portNumber)
mi := csm.NewMatchInfo(port.Host.Address, portNumber)
for i := 0; i < len(ms); i++ {
m := ms[i]
@ -26,7 +26,7 @@ func scanServiceUDP(port *ocmd.Port, ds *ocmd.DiscoverService, resultChan chan i
if m.Match(mi, 0, p) {
s := &ocmd.Service{
ServiceName: m.Name(),
Name: m.Name(),
Port: port,
DiscoveredDate: occu.NowPtr(),
}

18
internal/discoverer/port.go
View File

@ -2,9 +2,9 @@ package discoverer
import (
"fmt"
"net"
ocmd "git.loafle.net/overflow/commons-go/model/discovery"
ocmm "git.loafle.net/overflow/commons-go/model/meta"
"git.loafle.net/overflow/container_discovery/internal/discoverer/ipv4"
"git.loafle.net/overflow/container_discovery/internal/discoverer/ipv6"
)
@ -14,19 +14,13 @@ func scanPort(host *ocmd.Host, dp *ocmd.DiscoverPort, resultChan chan interface{
doneChan <- struct{}{}
}()
_, ipNet, err := net.ParseCIDR(host.Zone.Network)
if nil != err {
errChan <- err
return
}
switch len(ipNet.IP) {
case net.IPv4len:
switch ocmm.ToMetaIPTypeEnum(host.MetaIPType) {
case ocmm.MetaIPTypeEnumV4:
ipv4.ScanPort(host, dp, resultChan, errChan, stopChan)
case net.IPv6len:
case ocmm.MetaIPTypeEnumV6:
ipv6.ScanPort(host, dp, resultChan, errChan, stopChan)
default:
errChan <- fmt.Errorf("Discovery: Not supported ip length")
return
errChan <- fmt.Errorf("Discovery: Not supported MetaIPType")
}
}

19
internal/discoverer/service.go
View File

@ -2,9 +2,9 @@ package discoverer
import (
"fmt"
"net"
ocmd "git.loafle.net/overflow/commons-go/model/discovery"
ocmm "git.loafle.net/overflow/commons-go/model/meta"
"git.loafle.net/overflow/container_discovery/internal/discoverer/ipv4"
"git.loafle.net/overflow/container_discovery/internal/discoverer/ipv6"
)
@ -14,20 +14,13 @@ func scanService(port *ocmd.Port, ds *ocmd.DiscoverService, resultChan chan inte
doneChan <- struct{}{}
}()
_, ipNet, err := net.ParseCIDR(port.Host.Zone.Network)
if nil != err {
errChan <- err
return
}
switch len(ipNet.IP) {
case net.IPv4len:
switch ocmm.ToMetaIPTypeEnum(port.Host.MetaIPType) {
case ocmm.MetaIPTypeEnumV4:
ipv4.ScanService(port, ds, resultChan, errChan, stopChan)
case net.IPv6len:
case ocmm.MetaIPTypeEnumV6:
ipv6.ScanService(port, ds, resultChan, errChan, stopChan)
default:
errChan <- fmt.Errorf("Discovery: Not supported ip length")
return
errChan <- fmt.Errorf("Discovery: Not supported MetaIPType")
}
}

22
internal/discoverer/zone.go
View File

@ -3,10 +3,11 @@ package discoverer
import (
"net"
"regexp"
"strings"
cun "git.loafle.net/commons/util-go/net"
occu "git.loafle.net/overflow/commons-go/core/util"
ocmd "git.loafle.net/overflow/commons-go/model/discovery"
ocmm "git.loafle.net/overflow/commons-go/model/meta"
)
func scanZone(dz *ocmd.DiscoverZone, resultChan chan interface{}, errChan chan error, doneChan chan<- struct{}, stopChan chan struct{}) {
@ -17,8 +18,8 @@ func scanZone(dz *ocmd.DiscoverZone, resultChan chan interface{}, errChan chan e
var err error
var ifaces []net.Interface
var addrs []net.Addr
var ipnet *net.IPNet
var zones []*net.IPNet
var ipnet *cun.IPNet
var zones []*cun.IPNet
// var gwIP net.IP
// var gwIFace string
@ -32,7 +33,7 @@ func scanZone(dz *ocmd.DiscoverZone, resultChan chan interface{}, errChan chan e
return
}
zones = make([]*net.IPNet, 0)
zones = make([]*cun.IPNet, 0)
for _, i := range ifaces {
@ -43,7 +44,7 @@ func scanZone(dz *ocmd.DiscoverZone, resultChan chan interface{}, errChan chan e
for _, addr := range addrs {
if _, ipnet, err = net.ParseCIDR(addr.String()); nil != err {
if _, ipnet, err = cun.ParseCIDR(addr.String()); nil != err {
errChan <- err
continue
}
@ -57,10 +58,17 @@ func scanZone(dz *ocmd.DiscoverZone, resultChan chan interface{}, errChan chan e
Network: ipnet.String(),
Iface: i.Name,
Mac: i.HardwareAddr.String(),
IPV4: strings.Split(addr.String(), "/")[0],
Address: addr.String(),
DiscoveredDate: occu.NowPtr(),
}
switch ipnet.Version() {
case 6:
z.MetaIPType = ocmm.ToMetaIPType(ocmm.MetaIPTypeEnumV6)
default:
z.MetaIPType = ocmm.ToMetaIPType(ocmm.MetaIPTypeEnumV4)
}
resultChan <- z
}
}
@ -80,7 +88,7 @@ func checkExclude(ep []string, iface string) bool {
return false
}
func checkSameZone(zones []*net.IPNet, ipnet *net.IPNet) bool {
func checkSameZone(zones []*cun.IPNet, ipnet *cun.IPNet) bool {
for _, i := range zones {
if i.Contains(ipnet.IP) {
return true

8
service/DiscoveryService.go
View File

@ -86,13 +86,17 @@ func (s *DiscoveryService) DiscoverService(requesterID string, port *ocmd.Port,
}
func (s *DiscoveryService) StopDiscovery(requesterID string) error {
logging.Logger().Debugf("Request DiscoveryService.StopDiscovery")
_stopChan, ok := s.pendingDiscovery.Load(requesterID)
if !ok {
return fmt.Errorf("discovery request for [%s] is not exist", requesterID)
}
stopChan := _stopChan.(chan struct{})
close(stopChan)
stopChan <- struct{}{}
logging.Logger().Debugf("Close DiscoveryService.StopDiscovery")
return nil
}
@ -152,8 +156,8 @@ func (s *DiscoveryService) handleDiscovery(requesterID string, discoveryFunc fun
}
data.Release()
case <-stopChan:
logging.Logger().Debugf("DiscoveryService.StopDiscovery")
s.discoverer.Stop()
return nil
}
}
}