From c70ce6375fe2031db287d4dd8872c662198fc4d5 Mon Sep 17 00:00:00 2001 From: crusader Date: Sat, 14 Apr 2018 20:04:07 +0900 Subject: [PATCH] ing --- client/central/auth.go | 9 +- client/central/cnetral.go | 22 +---- client/central/data.go | 32 ++++++++ client/central/probe.go | 36 ++++++++ config.json | 7 -- config/config.go | 42 ++++++++++ main.go | 5 +- probe/probe.go | 167 ++++++++------------------------------ 8 files changed, 151 insertions(+), 169 deletions(-) diff --git a/client/central/auth.go b/client/central/auth.go index 3c36346..3ab92e7 100644 --- a/client/central/auth.go +++ b/client/central/auth.go @@ -12,10 +12,11 @@ import ( ocnc "git.loafle.net/overflow/commons-go/noauthprobe/config" ocncc "git.loafle.net/overflow/commons-go/noauthprobe/constants" "git.loafle.net/overflow/probe/auth/info" + "git.loafle.net/overflow/probe/config" ) -func NewAuth(tempkeyHandler func(tempkey string), services []interface{}) (*crc.Client, error) { - config := getConfig() +func NewAuth(tempKeyHandler func(tempKey string), services []interface{}) (*crc.Client, error) { + config := config.GetConfig() if nil == config { return nil, fmt.Errorf("Config is not available") } @@ -50,8 +51,8 @@ func NewAuth(tempkeyHandler func(tempkey string), services []interface{}) (*crc. switch authConfig.State() { case ocnc.AuthStateTypeNotRegisterd: tempProbeKey := res.Header.Get(ocncc.HTTPResponseHeaderKey_NoAuthProbe_SetTempProbeKey) - if nil != tempkeyHandler { - tempkeyHandler(tempProbeKey) + if nil != tempKeyHandler { + tempKeyHandler(tempProbeKey) } default: } diff --git a/client/central/cnetral.go b/client/central/cnetral.go index e8cab76..fb988fd 100644 --- a/client/central/cnetral.go +++ b/client/central/cnetral.go @@ -4,21 +4,17 @@ import ( "fmt" "net/url" "path" - "reflect" - cdr "git.loafle.net/commons/di-go/registry" - logging "git.loafle.net/commons/logging-go" crc "git.loafle.net/commons/rpc-go/client" crpj "git.loafle.net/commons/rpc-go/protocol/json" crr "git.loafle.net/commons/rpc-go/registry" csc "git.loafle.net/commons/server-go/client" csswc "git.loafle.net/commons/server-go/socket/web/client" - cur "git.loafle.net/commons/util-go/reflect" "git.loafle.net/overflow/probe/config" ) func newConnector(name string, entryPath string) (*csswc.Connectors, error) { - config := getConfig() + config := config.GetConfig() if nil == config { return nil, fmt.Errorf("Config is not available") } @@ -57,19 +53,3 @@ func newClient(name string, connector csc.Connector, services []interface{}) *cr Name: name, } } - -func getConfig() *config.Config { - _config, err := cdr.GetInstanceByName("Config") - if nil != err { - logging.Logger().Error(err) - return nil - } - config, ok := _config.(*config.Config) - if !ok { - _, pkg, n := cur.GetTypeInfo(reflect.TypeOf(_config)) - logging.Logger().Errorf("Cannot convert [%s]%s to Config type", pkg, n) - return nil - } - - return config -} diff --git a/client/central/data.go b/client/central/data.go index 4df274a..76e0d52 100644 --- a/client/central/data.go +++ b/client/central/data.go @@ -1 +1,33 @@ package central + +import ( + "fmt" + "net/http" + + crc "git.loafle.net/commons/rpc-go/client" + ocnpc "git.loafle.net/overflow/commons-go/probe/constants" + "git.loafle.net/overflow/probe/config" +) + +func NewData() (*crc.Client, error) { + config := config.GetConfig() + if nil == config { + return nil, fmt.Errorf("Config is not available") + } + + connector, err := newConnector("Data", ocnpc.HTTPEntry_Data) + if nil != err { + return nil, err + } + + connector.RequestHeader = func() http.Header { + header := make(map[string][]string) + header[ocnpc.HTTPRequestHeaderKey_Probe_Method] = []string{ocnpc.HTTPRequestHeaderValue_Probe_Method_Connect} + header[ocnpc.HTTPRequestHeaderKey_Probe_ProbeKey] = []string{*config.Probe.Key} + return header + } + connector.ResponseHandler = func(res *http.Response) { + } + + return newClient("Data", connector, nil), nil +} diff --git a/client/central/probe.go b/client/central/probe.go index 4df274a..1567b26 100644 --- a/client/central/probe.go +++ b/client/central/probe.go @@ -1 +1,37 @@ package central + +import ( + "fmt" + "net/http" + + crc "git.loafle.net/commons/rpc-go/client" + ocnpc "git.loafle.net/overflow/commons-go/probe/constants" + "git.loafle.net/overflow/probe/config" +) + +func NewProbe(encryptionKeyHandler func(encryptionKey string), services []interface{}) (*crc.Client, error) { + config := config.GetConfig() + if nil == config { + return nil, fmt.Errorf("Config is not available") + } + + connector, err := newConnector("Probe", ocnpc.HTTPEntry_Probe) + if nil != err { + return nil, err + } + + connector.RequestHeader = func() http.Header { + header := make(map[string][]string) + header[ocnpc.HTTPRequestHeaderKey_Probe_Method] = []string{ocnpc.HTTPRequestHeaderValue_Probe_Method_Connect} + header[ocnpc.HTTPRequestHeaderKey_Probe_ProbeKey] = []string{*config.Probe.Key} + return header + } + connector.ResponseHandler = func(res *http.Response) { + encryptionKey := res.Header.Get(ocnpc.HTTPResponseHeaderKey_Probe_SetEncryptionKey) + if nil != encryptionKeyHandler { + encryptionKeyHandler(encryptionKey) + } + } + + return newClient("Probe", connector, services), nil +} diff --git a/config.json b/config.json index a886ce6..80cd561 100644 --- a/config.json +++ b/config.json @@ -14,13 +14,6 @@ "pongTimeout": 60, "pingTimeout": 10, "pingPeriod": 9 - }, - "proxy": { - "host": "", - "port": 9090, - "useAuth": true, - "user": "", - "password": "" } }, "probe": { diff --git a/config/config.go b/config/config.go index a1fa122..9a23484 100644 --- a/config/config.go +++ b/config/config.go @@ -1,12 +1,54 @@ package config import ( + "reflect" + + cdr "git.loafle.net/commons/di-go/registry" + "git.loafle.net/commons/logging-go" + cur "git.loafle.net/commons/util-go/reflect" ocpc "git.loafle.net/overflow/commons-go/probe/config" ) +const ( + ConfigKey = "Config" + ConfigDirKey = "ConfigDir" +) + type Config struct { Account *ocpc.Account `required:"true" json:"account" yaml:"account" toml:"account"` Central *ocpc.Central `required:"true" json:"central" yaml:"central" toml:"central"` Probe *ocpc.Probe `required:"true" json:"probe" yaml:"probe" toml:"probe"` Paths map[string]string `required:"true" json:"paths" yaml:"paths" toml:"paths"` } + +func GetConfig() *Config { + _config, err := cdr.GetInstanceByName(ConfigKey) + if nil != err { + logging.Logger().Error(err) + return nil + } + config, ok := _config.(*Config) + if !ok { + _, pkg, n := cur.GetTypeInfo(reflect.TypeOf(_config)) + logging.Logger().Errorf("Cannot convert [%s]%s to Config type", pkg, n) + return nil + } + + return config +} + +func GetConfigDir() string { + _configDir, err := cdr.GetInstanceByName(ConfigDirKey) + if nil != err { + logging.Logger().Error(err) + return "" + } + configDir, ok := _configDir.(string) + if !ok { + _, pkg, n := cur.GetTypeInfo(reflect.TypeOf(_configDir)) + logging.Logger().Errorf("Cannot convert [%s]%s to string type", pkg, n) + return "" + } + + return configDir +} diff --git a/main.go b/main.go index 6278c8e..21c1418 100644 --- a/main.go +++ b/main.go @@ -35,8 +35,9 @@ func main() { if err := configuration.Load(_config, ocpc.ConfigFileName); nil != err { logging.Logger().Panic(err) } - cdr.RegisterResource("Config", _config) - cdr.RegisterResource("ConfigDir", *configDir) + + cdr.RegisterResource(config.ConfigKey, _config) + cdr.RegisterResource(config.ConfigDirKey, *configDir) var instance interface{} diff --git a/probe/probe.go b/probe/probe.go index 0dda66e..6b57044 100644 --- a/probe/probe.go +++ b/probe/probe.go @@ -3,33 +3,13 @@ package probe import ( "context" "fmt" - "net/http" - "path" "sync" - "time" - "git.loafle.net/commons/configuration-go" - cdr "git.loafle.net/commons/di-go/registry" - logging "git.loafle.net/commons/logging-go" - crc "git.loafle.net/commons/rpc-go/client" - crpj "git.loafle.net/commons/rpc-go/protocol/json" - crr "git.loafle.net/commons/rpc-go/registry" - csswc "git.loafle.net/commons/server-go/socket/web/client" - occa "git.loafle.net/overflow/commons-go/core/annotation" - ocnc "git.loafle.net/overflow/commons-go/noauthprobe/config" - ocncc "git.loafle.net/overflow/commons-go/noauthprobe/constants" - ocpc "git.loafle.net/overflow/commons-go/probe/config" - "git.loafle.net/overflow/probe/auth/info" - _ "git.loafle.net/overflow/probe/auth/service" - "git.loafle.net/overflow/probe/config" + // For service + _ "git.loafle.net/overflow/probe/service" ) type Probe struct { - Config *config.Config - ConfigDir string - - client *crc.Client - stopChan chan struct{} stopWg sync.WaitGroup } @@ -39,13 +19,15 @@ func (p *Probe) Start() error { return fmt.Errorf("already running. Stop it before starting it again") } - if err := p.initClient(); nil != err { - return err - } + // services, err := cdr.GetInstancesByAnnotationType(occa.RPCServiceAnnotationType) + // if nil != err { + // return err + // } - if err := p.client.Start(); nil != err { - return err - } + // client, err := central.NewProbe(p.HandleEncryptionKey, services) + // if nil != err { + // return err + // } p.stopChan = make(chan struct{}) @@ -71,117 +53,32 @@ func (p *Probe) logHeader() string { return "Probe:" } -func (p *Probe) initService() (crr.RPCInvoker, error) { - services, err := cdr.GetInstancesByAnnotationType(occa.RPCServiceAnnotationType) - if nil != err { - return nil, err - } +func (p *Probe) HandleEncryptionKey(encryptionKey string) { - rpcRegistry := crr.NewRPCRegistry() - rpcRegistry.RegisterServices(services...) - - return rpcRegistry, nil } -func (p *Probe) initClient() error { - _connector := p.Config.Central.Connector.Clone() - connector := _connector.(*csswc.Connectors) +func (p *Probe) handleProbe() { + // var err error + // defer func() { + // if nil != client { + // err = client.Stop(context.Background()) + // } - header := make(map[string][]string) + // a.stopWg.Done() + // endChan <- err + // }() - switch p.authConfig.State() { - case ocnc.AuthStateTypeRegisterd: - header[ocncc.HTTPRequestHeaderKey_NoAuthProbe_Method] = []string{ocncc.HTTPRequestHeaderValue_NoAuthProbe_Method_Connect} - header[ocncc.HTTPRequestHeaderKey_NoAuthProbe_TempProbeKey] = []string{*p.authConfig.TempKey} - default: - rh, err := info.GetRegistHeader(p.Config.Account.APIKey) - if nil != err { - return err - } - header[ocncc.HTTPRequestHeaderKey_NoAuthProbe_Method] = []string{ocncc.HTTPRequestHeaderValue_NoAuthProbe_Method_Regist} - header[ocncc.HTTPRequestHeaderKey_NoAuthProbe_Info] = []string{rh} - } + // if err = client.Start(); nil != err { + // logging.Logger().Error(err) + // return + // } - centralURL := fmt.Sprintf("ws://%s:%d%s", p.Config.Central.Host, p.Config.Central.Port, ocncc.HTTPEntry_Auth) - - logging.Logger().Debugf("%s central %s", p.logHeader(), centralURL) - - connector.URL = centralURL - connector.RequestHeader = header - connector.ResponseHandler = func(res *http.Response) { - switch p.authConfig.State() { - case ocnc.AuthStateTypeNotRegisterd: - tempProbeKey := res.Header.Get(ocncc.HTTPResponseHeaderKey_NoAuthProbe_SetTempProbeKey) - p.tempKeyChan <- tempProbeKey - default: - } - } - - rpcInvoker, err := p.initService() - if nil != err { - return err - } - codec := crpj.NewClientCodec() - - p.client = &crc.Client{ - Connector: connector, - Codec: codec, - RPCInvoker: rpcInvoker, - Name: "Authenticator", - } - - return nil -} - -func (p *Probe) handleProbe(endChan chan<- error) { - var err error - defer func() { - if nil != p.client { - err = p.client.Stop(context.Background()) - } - - p.stopWg.Done() - endChan <- err - }() - - for { - select { - case probeKey, ok := <-p.accpetedChan: - if !ok { - return - } - logging.Logger().Infof("%s accepted by central", p.logHeader()) - p.Config.Probe.Key = &probeKey - err = configuration.Save(p.Config, path.Join(p.ConfigDir, ocpc.ConfigFileName), true) - if nil != err { - logging.Logger().Errorf("%s %v", p.logHeader(), err) - } - return - case _, ok := <-p.deniedChan: - if !ok { - return - } - logging.Logger().Infof("%s denied by central", p.logHeader()) - n := time.Now() - p.authConfig.DenyDate = &n - err = configuration.Save(p.authConfig, path.Join(p.ConfigDir, ocnc.ConfigFileName), true) - if nil != err { - logging.Logger().Errorf("%s %v", p.logHeader(), err) - } - return - case tempKey, ok := <-p.tempKeyChan: - if !ok { - return - } - logging.Logger().Infof("%s registered by central", p.logHeader()) - p.authConfig.TempKey = &tempKey - err = configuration.Save(p.authConfig, path.Join(p.ConfigDir, ocnc.ConfigFileName), true) - if nil != err { - logging.Logger().Errorf("%s %v", p.logHeader(), err) - return - } - case <-p.stopChan: - return - } - } + // for { + // select { + // case err = <-authDoneChan: + // return + // case <-a.stopChan: + // return + // } + // } }