From 9589b920953b91885732bbed179fa12da4f95825 Mon Sep 17 00:00:00 2001 From: crusader Date: Fri, 23 Mar 2018 01:11:03 +0900 Subject: [PATCH] ing --- commons/annotation/service.go | 22 ---------------- discovery/discovery.go | 48 +++++++++++++++-------------------- glide.yaml | 2 +- server/server.go | 20 +++++++++++---- server/socket_handlers.go | 10 +++----- service/DiscoveryService.go | 5 +++- service/service.go | 7 ++++- 7 files changed, 49 insertions(+), 65 deletions(-) delete mode 100644 commons/annotation/service.go diff --git a/commons/annotation/service.go b/commons/annotation/service.go deleted file mode 100644 index f473335..0000000 --- a/commons/annotation/service.go +++ /dev/null @@ -1,22 +0,0 @@ -package annotation - -// @Service() -// inherit @Component -import ( - "reflect" - - cda "git.loafle.net/commons_go/di/annotation" - cdia "git.loafle.net/commons_go/di/injection/annotation" -) - -const ( - ServiceTag = "@overFlow:Service" -) - -func init() { - cda.RegisterAnnotation(ServiceTag, reflect.TypeOf((*Service)(nil))) -} - -type Service struct { - cdia.Component -} diff --git a/discovery/discovery.go b/discovery/discovery.go index 15b8568..ca2cad2 100644 --- a/discovery/discovery.go +++ b/discovery/discovery.go @@ -7,6 +7,7 @@ import ( "git.loafle.net/commons_go/rpc" "git.loafle.net/commons_go/util/net/cidr" discoveryM "git.loafle.net/overflow/overflow_commons_go/modules/discovery/model" + oopcs "git.loafle.net/overflow/overflow_probe_container/service" ) var RPCServlet rpc.Servlet @@ -23,20 +24,20 @@ func DiscoveryDestroy() { discoverer = nil } -func DiscoverZone(requesterID string, dz *discoveryM.DiscoveryZone) { - discoverer.discoverZone(requesterID, dz) +func DiscoverZone(probeService *oopcs.ProbeService, requesterID string, dz *discoveryM.DiscoveryZone) { + discoverer.discoverZone(probeService, requesterID, dz) } -func DiscoverHost(requesterID string, zone *discoveryM.Zone, dh *discoveryM.DiscoveryHost) { - discoverer.discoverHost(requesterID, zone, dh) +func DiscoverHost(probeService *oopcs.ProbeService, requesterID string, zone *discoveryM.Zone, dh *discoveryM.DiscoveryHost) { + discoverer.discoverHost(probeService, requesterID, zone, dh) } -func DiscoverPort(requesterID string, host *discoveryM.Host, dp *discoveryM.DiscoveryPort) { - discoverer.discoverPort(requesterID, host, dp) +func DiscoverPort(probeService *oopcs.ProbeService, requesterID string, host *discoveryM.Host, dp *discoveryM.DiscoveryPort) { + discoverer.discoverPort(probeService, requesterID, host, dp) } -func DiscoverService(requesterID string, port *discoveryM.Port, ds *discoveryM.DiscoveryService) { - discoverer.discoverService(requesterID, port, ds) +func DiscoverService(probeService *oopcs.ProbeService, requesterID string, port *discoveryM.Port, ds *discoveryM.DiscoveryService) { + discoverer.discoverService(probeService, requesterID, port, ds) } func Stop() { @@ -73,7 +74,7 @@ func (d *discovery) stop() { logging.Logger().Infof("Discovery: discovery is stopped") } -func (d *discovery) discoverZone(requesterID string, dz *discoveryM.DiscoveryZone) { +func (d *discovery) discoverZone(probeService *oopcs.ProbeService, requesterID string, dz *discoveryM.DiscoveryZone) { go taskScan(d, func(resultChan chan interface{}, errChan chan error, doneChan chan struct{}, stopChan chan struct{}) { scanZone(dz, resultChan, errChan, doneChan, stopChan) @@ -81,7 +82,7 @@ func (d *discovery) discoverZone(requesterID string, dz *discoveryM.DiscoveryZon func(result interface{}) { z := result.(*discoveryM.Zone) logging.Logger().Debugf("zone: %v", z) - d.sendResult("DiscoveryService.DiscoveredZone", requesterID, z) + probeService.Send("DiscoveryService.DiscoveredZone", requesterID, z) if nil != dz.DiscoveryHost { cr, _ := cidr.NewCIDRRanger(z.Network) dh := &discoveryM.DiscoveryHost{ @@ -89,13 +90,13 @@ func (d *discovery) discoverZone(requesterID string, dz *discoveryM.DiscoveryZon LastScanRange: cr.Last().String(), DiscoveryPort: dz.DiscoveryHost.DiscoveryPort, } - d.discoverHost(requesterID, z, dh) + d.discoverHost(probeService, requesterID, z, dh) } }, ) } -func (d *discovery) discoverHost(requesterID string, zone *discoveryM.Zone, dh *discoveryM.DiscoveryHost) { +func (d *discovery) discoverHost(probeService *oopcs.ProbeService, requesterID string, zone *discoveryM.Zone, dh *discoveryM.DiscoveryHost) { go taskScan(d, func(resultChan chan interface{}, errChan chan error, doneChan chan struct{}, stopChan chan struct{}) { scanHost(zone, dh, resultChan, errChan, doneChan, stopChan) @@ -103,15 +104,15 @@ func (d *discovery) discoverHost(requesterID string, zone *discoveryM.Zone, dh * func(result interface{}) { h := result.(*discoveryM.Host) logging.Logger().Debugf("host: %v", h) - d.sendResult("DiscoveryService.DiscoveredHost", requesterID, h) + probeService.Send("DiscoveryService.DiscoveredHost", requesterID, h) if nil != dh.DiscoveryPort { - d.discoverPort(requesterID, h, dh.DiscoveryPort) + d.discoverPort(probeService, requesterID, h, dh.DiscoveryPort) } }, ) } -func (d *discovery) discoverPort(requesterID string, host *discoveryM.Host, dp *discoveryM.DiscoveryPort) { +func (d *discovery) discoverPort(probeService *oopcs.ProbeService, requesterID string, host *discoveryM.Host, dp *discoveryM.DiscoveryPort) { go taskScan(d, func(resultChan chan interface{}, errChan chan error, doneChan chan struct{}, stopChan chan struct{}) { scanPort(host, dp, resultChan, errChan, doneChan, stopChan) @@ -119,36 +120,27 @@ func (d *discovery) discoverPort(requesterID string, host *discoveryM.Host, dp * func(result interface{}) { p := result.(*discoveryM.Port) logging.Logger().Debugf("port: %v", p) - d.sendResult("DiscoveryService.DiscoveredPort", requesterID, p) + probeService.Send("DiscoveryService.DiscoveredPort", requesterID, p) if nil != dp.DiscoveryService { - d.discoverService(requesterID, p, dp.DiscoveryService) + d.discoverService(probeService, requesterID, p, dp.DiscoveryService) } }, ) } -func (d *discovery) discoverService(requesterID string, port *discoveryM.Port, ds *discoveryM.DiscoveryService) { +func (d *discovery) discoverService(probeService *oopcs.ProbeService, requesterID string, port *discoveryM.Port, ds *discoveryM.DiscoveryService) { go taskScan(d, func(resultChan chan interface{}, errChan chan error, doneChan chan struct{}, stopChan chan struct{}) { scanService(port, ds, resultChan, errChan, doneChan, stopChan) }, func(result interface{}) { s := result.(*discoveryM.Service) - d.sendResult("DiscoveryService.DiscoveredService", requesterID, s) + probeService.Send("DiscoveryService.DiscoveredService", requesterID, s) logging.Logger().Debugf("service: %s(%s)[%s:%s]", s.ServiceName, s.CryptoType, port.Host.IP, port.PortNumber) }, ) } -func (d *discovery) sendResult(method string, args ...interface{}) { - go RPCServlet.Send(method, args...) - // go notify.Notifier.Notify(method, args...) -} - -func (d *discovery) sendError() { - -} - func taskScan(d *discovery, task func(resultChan chan interface{}, errChan chan error, doneChan chan struct{}, stopChan chan struct{}), onResult func(result interface{})) { d.stopWg.Add(1) resultChan := make(chan interface{}) diff --git a/glide.yaml b/glide.yaml index 7fe304d..7b830a7 100644 --- a/glide.yaml +++ b/glide.yaml @@ -3,8 +3,8 @@ import: - package: git.loafle.net/commons_go/util - package: github.com/google/gopacket version: v1.1.14 -- package: git.loafle.net/commons_go/local_socket.git - package: git.loafle.net/commons_go/server - package: git.loafle.net/commons_go/rpc - package: gopkg.in/natefinch/npipe.v2 - package: git.loafle.net/commons_go/di +- package: git.loafle.net/overflow/overflow_commons_go diff --git a/server/server.go b/server/server.go index 750a81b..a9f4520 100644 --- a/server/server.go +++ b/server/server.go @@ -1,25 +1,29 @@ package server import ( + "reflect" + cdr "git.loafle.net/commons_go/di/registry" "git.loafle.net/commons_go/logging" crr "git.loafle.net/commons_go/rpc/registry" "git.loafle.net/commons_go/server" - oodca "git.loafle.net/overflow/overflow_discovery/commons/annotation" + ooca "git.loafle.net/overflow/overflow_commons_go/annotation" oods "git.loafle.net/overflow/overflow_discovery/service" oopcs "git.loafle.net/overflow/overflow_probe_container/server" + oopcService "git.loafle.net/overflow/overflow_probe_container/service" ) func New(pidPath string) server.Server { var ( - services []interface{} - err error + services []interface{} + probeService *oopcService.ProbeService + err error ) oods.InitService() rpcRegistry := crr.NewRPCRegistry() - if services, err = cdr.GetInstancesByAnnotationName(oodca.ServiceTag); nil != err { + if services, err = cdr.GetInstancesByAnnotationName(ooca.ServiceTag); nil != err { logging.Logger().Panic(err) } @@ -27,8 +31,14 @@ func New(pidPath string) server.Server { rpcRegistry.RegisterService(s, "") } + if _probeService, err := cdr.GetInstance(reflect.TypeOf((*oopcService.ProbeService)(nil))); nil != err { + logging.Logger().Panic(err) + } else { + probeService = _probeService.(*oopcService.ProbeService) + } + rpcSH := oopcs.NewRPCServletHandler(rpcRegistry) - socketHandler := newSocketHandler(rpcSH) + socketHandler := newSocketHandler(rpcSH, probeService) sh := newServerHandler(pidPath, socketHandler) s := oopcs.New(sh) diff --git a/server/socket_handlers.go b/server/socket_handlers.go index b9f35c5..85a09b6 100644 --- a/server/socket_handlers.go +++ b/server/socket_handlers.go @@ -3,16 +3,14 @@ package server import ( "net" - cRPC "git.loafle.net/commons_go/rpc" "git.loafle.net/commons_go/server" - "git.loafle.net/overflow/overflow_discovery/discovery" - oopc "git.loafle.net/overflow/overflow_probe_container" oopcs "git.loafle.net/overflow/overflow_probe_container/server" + oopcService "git.loafle.net/overflow/overflow_probe_container/service" ) -func newSocketHandler(rpcSH oopcs.RPCServletHandler) SocketHandler { +func newSocketHandler(rpcSH oopcs.RPCServletHandler, probeService *oopcService.ProbeService) SocketHandler { sh := &SocketHandlers{} - sh.SocketHandler = oopcs.NewSocketHandler(rpcSH) + sh.SocketHandler = oopcs.NewSocketHandler(rpcSH, probeService) return sh } @@ -36,11 +34,9 @@ func (sh *SocketHandlers) Handshake(socketCTX server.SocketContext, conn net.Con func (sh *SocketHandlers) OnConnect(soc server.Socket) { sh.SocketHandler.OnConnect(soc) - discovery.RPCServlet = soc.Context().GetAttribute(oopc.RPCServletKey).(cRPC.Servlet) } func (sh *SocketHandlers) OnDisconnect(soc server.Socket) { - discovery.RPCServlet = nil sh.SocketHandler.OnDisconnect(soc) } diff --git a/service/DiscoveryService.go b/service/DiscoveryService.go index a8e5c62..b36257d 100644 --- a/service/DiscoveryService.go +++ b/service/DiscoveryService.go @@ -7,6 +7,7 @@ import ( cdr "git.loafle.net/commons_go/di/registry" discoveryM "git.loafle.net/overflow/overflow_commons_go/modules/discovery/model" "git.loafle.net/overflow/overflow_discovery/discovery" + oopcs "git.loafle.net/overflow/overflow_probe_container/service" ) func init() { @@ -15,11 +16,13 @@ func init() { type DiscoveryService struct { cda.TypeAnnotation `annotation:"@overFlow:Service()"` + + ProbeService *oopcs.ProbeService `annotation:"@Inject()"` } func (ds *DiscoveryService) DiscoverZone(requesterID string, dz *discoveryM.DiscoveryZone) error { - discovery.DiscoverZone(requesterID, dz) + discovery.DiscoverZone(ds.ProbeService, requesterID, dz) return nil } diff --git a/service/service.go b/service/service.go index fb7d721..83c4f6f 100644 --- a/service/service.go +++ b/service/service.go @@ -1,8 +1,13 @@ package service +import ( + oopcs "git.loafle.net/overflow/overflow_probe_container/service" +) + func InitService() { + oopcs.InitService() } func DestroyService() { - + oopcs.DestroyService() }