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

ing

Browse Source
This commit is contained in:
crusader 2018-04-14 20:04:07 +09:00
parent 7137f8129e
commit c70ce6375f
8 changed files with 151 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
client/central/auth.go
View File

@ -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:
}

22
client/central/cnetral.go
View File

@ -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
}

32
client/central/data.go
View File

@ -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
}

36
client/central/probe.go
View File

@ -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
}

7
config.json
View File

@ -14,13 +14,6 @@
"pongTimeout": 60,
"pingTimeout": 10,
"pingPeriod": 9
},
"proxy": {
"host": "",
"port": 9090,
"useAuth": true,
"user": "",
"password": ""
}
},
"probe": {

42
config/config.go
View File

@ -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
}

5
main.go
View File

@ -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{}

167
probe/probe.go
View File

@ -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
// }
// }
}