added

probe task

proxy/discovery/discovery_service.go

@@ -0,0 +1,47 @@
+package discovery
+
+import (
+	"git.loafle.net/overflow/overflow_service/proxy/probe"
+	"git.loafle.net/overflow/overflow_service/proxy/meta"
+	"encoding/json"
+)
+
+type Discovery struct {
+	StartIp  int64			`json:"startIp,omitempty"`
+	EndIp	int64			`json:"endIp,omitempty"`
+	StartPort int			`json:"startPort,omitempty"`
+	EndPort int			`json:"endPort,omitempty"`
+	ExcludeIp []int64		`json:"excludeIp,omitempty"`
+	Probe  *probe.Probe		`json:"probe,omitempty"`
+}
+
+
+type DiscoveryService struct {
+
+}
+
+func NewDiscoveryService() *DiscoveryService {
+	return &DiscoveryService{}
+}
+
+
+func (dis *DiscoveryService)Discovery(d *Discovery) (string, error) {
+
+	pts := probe.NewProbeTaskService()
+
+	bytes,err := json.Marshal(d)
+
+	if err != nil {
+		return "", err
+	}
+
+	pt := probe.NewProbeTask(meta.NewMetaProbeTaskType(meta.PROBE_TASK_TYPE_DISOCVERY), string(bytes), d.Probe)
+
+	out, err := pts.Regist(pt)
+
+	if err != nil {
+		return "", err
+	}
+
+	return out, nil
+}

proxy/discovery/discovery_service_test.go

@@ -0,0 +1,33 @@
+package discovery
+
+import (
+	"testing"
+	"git.loafle.net/overflow/overflow_service/proxy/probe"
+)
+
+func TestDiscovery(t *testing.T) {
+
+	d := &Discovery{}
+
+	p := &probe.Probe{}
+	p.Id = "1"
+
+	d.Probe = p
+	d.StartIp = 3232235521
+	d.EndIp = 3232235774
+
+	d.StartPort = 1
+	d.EndPort = 50000
+
+	ds := NewDiscoveryService()
+
+	out, err := ds.Discovery(d)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	t.Log(out)
+
+
+}

proxy/meta/meta_probe_task_type.go

@@ -0,0 +1,37 @@
+package meta
+
+import (
+	"encoding/json"
+	"git.loafle.net/overflow/commons_go/model/timestamp"
+	"strconv"
+)
+
+
+const (
+	PROBE_TASK_TYPE_DISOCVERY = 1
+
+)
+var metaProbeTaskTypeMap = map[int]string{
+	1: "DISOCVERY",
+}
+
+
+type MetaProbeTaskType struct {
+	Id json.Number 		`json:"id,Number,omitempty"`
+	Name string		`json:"name,omitempty"`
+	Description string		`json:"description,omitempty"`
+	CreateDate timestamp.Timestamp		`json:"createDate,omitempty"`
+}
+
+func NewMetaProbeTaskType(types int) *MetaProbeTaskType {
+
+	str := metaProbeTaskTypeMap[types]
+
+	if len(str) <= 0 {
+		return nil
+	}
+	return &MetaProbeTaskType{
+		Id:json.Number(strconv.Itoa(types)),
+		Name:str,
+	}
+}

proxy/probe/probe_task_service.go

@@ -0,0 +1,60 @@
+package probe
+
+import (
+	"encoding/json"
+	"git.loafle.net/overflow/overflow_service/proxy/meta"
+	"git.loafle.net/overflow/commons_go/model/timestamp"
+	"git.loafle.net/overflow/overflow_service/proxy/utils"
+)
+
+type ProbeTask struct {
+	Id              json.Number   `json:"id,Number,omitempty"`
+	MetaProbeTaskType	*meta.MetaProbeTaskType	`json:"metaProbeTaskType,omitempty"`
+	Probe *Probe		`json:"probe,omitempty"`
+	Data     string        `json:"data,omitempty"`
+	CreateDate	timestamp.Timestamp	`json:"createDate,omitempty"`
+	SendDate	timestamp.Timestamp	`json:"sendDate,omitempty"`
+	StartDate	timestamp.Timestamp	`json:"startDate,omitempty"`
+	EndDate	timestamp.Timestamp	`json:"startDate,omitempty"`
+	Succeed bool		`json:"succeed,omitempty"`
+}
+
+func NewProbeTask(types *meta.MetaProbeTaskType, data string, p *Probe) *ProbeTask {
+
+	return &ProbeTask{
+		MetaProbeTaskType:types,
+		Data:data,
+		Probe:p,
+	}
+
+}
+
+type ProbeTaskService struct {
+
+}
+
+func NewProbeTaskService() *ProbeTaskService{
+	return &ProbeTaskService{}
+}
+
+func(pts* ProbeTaskService)Regist(pt *ProbeTask) (string, error) {
+
+	out, err := utils.InvokeDBByModel("probeTask","save", pt, utils.MODEL_PROBE_TASK)
+
+	if err != nil {
+		return "", err
+	}
+
+	return out, nil
+}
+
+func(pts* ProbeTaskService)ReadAllByProbe(p *Probe) (string, error) {
+
+	out, err := utils.InvokeDBByModel("probeTask","findAllByProbe", p, utils.MODEL_PROBE)
+
+	if err != nil {
+		return "", err
+	}
+
+	return out, nil
+}

proxy/probe/probe_task_service_test.go

@@ -0,0 +1,45 @@
+package probe
+
+import (
+	"testing"
+	"git.loafle.net/overflow/overflow_service/proxy/meta"
+)
+
+func TestCreate(t *testing.T) {
+	p := &Probe{}
+	p.Id = "1"
+
+	data := ""
+
+	pt := NewProbeTask(meta.NewMetaProbeTaskType(meta.PROBE_TASK_TYPE_DISOCVERY), data, p)
+
+	pts := NewProbeTaskService()
+
+	out, err := pts.Regist(pt)
+
+	if err != nil{
+		t.Fatal(err)
+	}
+
+	t.Log(out)
+}
+
+
+func TestListByProbe(t *testing.T) {
+
+	p := &Probe{}
+
+	p.Id = "1"
+
+	pts := NewProbeTaskService()
+	out, err := pts.ReadAllByProbe(p)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	t.Log(out)
+
+
+
+}