Golang Result.Data方法代码示例

func getTagStatus(reponame, itemname, tagname string) (string, error) {
	uri := "/daemon/" + reponame + "/" + itemname + "/" + tagname
	resp, err := commToDaemon("get", uri, nil)
	if err != nil {
		return "", err
	}
	result := ds.Result{}
	tagStatus := ds.TagStatus{}
	result.Data = &tagStatus
	respbody, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", err
	}
	if resp.StatusCode == http.StatusOK {
		err = json.Unmarshal(respbody, &result)
		if err != nil {
			return "", err
		}
	} else if resp.StatusCode == http.StatusUnauthorized {
		return "", errors.New("Not login.")
	} else {
		return "", errors.New(string(respbody))
	}

	return tagStatus.Status, nil
}

func deleteItemsAccordingToHeartbeat(body []byte) {
	log.Debug("deleteItemsAccordingToHeartbeat() BEGIN:", string(body))
	result := ds.Result{}
	itemEvent := &Event{}
	result.Data = itemEvent
	itemsdelete := []ItemDel{}
	itemEvent.Data = &itemsdelete

	if err := json.Unmarshal(body, &result); err == nil {
		log.Debug("items delete:", itemsdelete)
		for _, v := range itemsdelete {
			log.Debugf("delete item according to heartbeat: %v/%v\n", v.Repname, v.Itemname)
			err := delTagsForDelItem(v.Repname, v.Itemname)
			if err != nil {
				log.Error(err)
				return
			}

			err = delItem(v.Repname, v.Itemname)
			if err != nil {
				log.Error(err)
				return
			}
			log.Infof("Delete data item %v/%v according to heartbeat successfully.\n", v.Repname, v.Itemname)
		}
	} else {
		log.Warn("Unmarshal error:", err)
	}
}

func getItemStatus(reponame, itemname string) (string, error) {
	uri := "/repositories/" + reponame + "/" + itemname
	resp, err := commToDaemon("get", uri, nil)
	if err != nil {
		return "", err
	}
	result := ds.Result{}
	itemInfo := ds.ItemInfo{}
	result.Data = &itemInfo
	respbody, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", err
	}
	if resp.StatusCode == http.StatusOK {
		err = json.Unmarshal(respbody, &result)
		if err != nil {
			return "", err
		}
	} else {
		return "", errors.New(string(respbody))
		//showResponse(resp)
	}

	uri = "/heartbeat/status/" + itemInfo.Create_user
	resp, err = commToDaemon("get", uri, nil)
	if err != nil {
		return "", err
	}
	itemStatus := ds.ItemStatus{}
	result.Data = &itemStatus
	respbody, err = ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", err
	}
	if resp.StatusCode == http.StatusOK {
		err = json.Unmarshal(respbody, &result)
		if err != nil {
			return "", err
		}
	} else {
		showResponse(resp)
	}

	return itemStatus.Status, nil
}

func repoResp(icmd int, respbody []byte, repo, item, tag string) {
	//fmt.Println(string(respbody))
	result := ds.Result{Code: ResultOK}
	if icmd == Repos {
		repos := []ds.Repositories{}
		result.Data = &repos
		err := json.Unmarshal(respbody, &result)
		if err != nil {
			panic(err)
		}
		fmt.Printf("%-16s\n", "REPOSITORY") //, "UPDATETIME", "COMMENT")

		for _, v := range repos {
			fmt.Printf("%-16s\n", v.RepositoryName) //, v.Optime, v.Comment)
		}
	} else if icmd == ReposReponame {
		onerepo := ds.Repository{}
		result.Data = &onerepo
		err := json.Unmarshal(respbody, &result)
		if err != nil {
			panic(err)
		}
		fmt.Printf("REPOSITORY/DATAITEM\n")

		for _, v := range onerepo.DataItems {
			fmt.Printf("%s/%s\n", repo, v)
		}

	} else if icmd == ReposReponameDataItem {
		itemStatus, err := getItemStatus(repo, item)
		if err != nil {
			fmt.Println("Error :", err)
			return
		}
		var tagStatus string
		repoitemtags := ds.Data{}
		result.Data = &repoitemtags
		err = json.Unmarshal(respbody, &result)
		if err != nil {
			fmt.Println("Error :", err)
			return
		}
		abnormalTags, err := getTagStatusOfItem(repo, item)
		if err != nil {
			fmt.Println("Error :", err)
			return
		}

		repoitemname := repo + "/" + item

		ctag := []string{"REPOSITORY/ITEM:TAG"}
		cupdatetime := []string{"UPDATETIME"}
		ccomment := []string{"COMMENT"}
		cstatus := []string{"STATUS"}

		if itemStatus == "offline" {
			for _, v := range repoitemtags.Taglist {
				//fmt.Printf("%s/%s:%s\t%s\t%s\t%s\n", repo, item, v.Tag, v.Optime, v.Comment, "ABNORMAL")
				ctag = append(ctag, repo+"/"+item+":"+v.Tag)
				cupdatetime = append(cupdatetime, v.Optime)
				ccomment = append(ccomment, v.Comment)
				cstatus = append(cstatus, "ABNORMAL")
			}
		} else {
			for _, v := range repoitemtags.Taglist {
				repoitemtag := repoitemname + ":" + v.Tag
				tagStatus = judgeTag(abnormalTags, repoitemtag)
				//fmt.Printf("%s/%s:%s\t%s\t%s\t%s\n", repo, item, v.Tag, v.Optime, v.Comment, tagStatus)
				ctag = append(ctag, repo+"/"+item+":"+v.Tag)
				cupdatetime = append(cupdatetime, v.Optime)
				ccomment = append(ccomment, v.Comment)
				cstatus = append(cstatus, tagStatus)
			}
		}
		utils.PrintFmt(ctag, cupdatetime, ccomment, cstatus)

	} else if icmd == ReposReponameDataItemTag {
		itemStatus, err := getItemStatus(repo, item)
		if err != nil {
			fmt.Println("Error :", err)
			return
		}
		tagStatus, err := getTagStatus(repo, item, tag)
		if err != nil {
			fmt.Println("Error :", err)
			return
		}
		onetag := ds.Tag{}
		result.Data = &onetag
		err = json.Unmarshal(respbody, &result)
		if err != nil {
			fmt.Println("Error :", err)
			return
		}
		//n, _ := fmt.Printf("%s\t%s\t%s\t\t%s\n", "REPOSITORY/ITEM:TAG", "UPDATETIME", "COMMENT", "STATUS")
		ctag := []string{"REPOSITORY/ITEM:TAG"}
		cupdatetime := []string{"UPDATETIME"}
		ccomment := []string{"COMMENT"}
		cstatus := []string{"STATUS"}
		if itemStatus == "offline" {
//.........这里部分代码省略.........

func GetPulledRepoInfo(dpName, repoName string, offset int64, limit int) ([]ds.PulledItemInfo, error) {

	var pulledItemInfo ds.PulledItemInfo
	pulledItemInfos := make([]ds.PulledItemInfo, 0)

	sql := fmt.Sprintf(`SELECT DPID FROM DH_DP WHERE DPNAME = '%s' AND STATUS = 'A';`, dpName)
	row, err := g_ds.QueryRow(sql)
	if err != nil {
		l := log.Error(err)
		logq.LogPutqueue(l)
		return nil, err
	}

	var dpid int
	row.Scan(&dpid)

	sql = fmt.Sprintf(`SELECT DATAITEM ,ITEMDESC
		FROM DH_DP_RPDM_MAP 
		WHERE DPID = %d AND REPOSITORY = '%s' AND PUBLISH = 'N' AND STATUS = 'A' 
		ORDER BY RPDMID 
		LIMIT %v OFFSET %v;`, dpid, repoName, limit, offset)
	rows, err := g_ds.QueryRows(sql)
	if err != nil {
		l := log.Error(err)
		logq.LogPutqueue(l)
		return nil, err
	}

	result := ds.Result{}
	pages := ds.ResultPages{}
	orderInfoSlice := []ds.OrderInfo{}
	pages.Results = &orderInfoSlice
	result.Data = &pages

	for rows.Next() {
		rows.Scan(&pulledItemInfo.ItemName, &pulledItemInfo.Location)

		path := "/api/subscriptions/pull/" + repoName + "/" + pulledItemInfo.ItemName
		resp, err := commToServerGetRsp("get", path, nil)
		if err != nil {
			l := log.Error(err)
			logq.LogPutqueue(l)
			return nil, err
		}
		defer resp.Body.Close()

		if resp.StatusCode == http.StatusUnauthorized {
			pulledItemInfo.SignTime = nil
			log.Debug("resp.StatusCode == http.StatusUnauthorized")
		} else if resp.StatusCode != http.StatusOK {
			err = errors.New("request subscriptions api failed.")
			l := log.Error(err)
			logq.LogPutqueue(l)
			return nil, err
		} else {
			respbody, err := ioutil.ReadAll(resp.Body)
			if err != nil {
				l := log.Error(err)
				logq.LogPutqueue(l)
				return nil, err
			} else {
				err = json.Unmarshal(respbody, &result)
				if err != nil {
					err = errors.New("unmarshal failed.")
					l := log.Error(err)
					logq.LogPutqueue(l)
					return nil, err
				}

				if len(orderInfoSlice) > 0 {
					//Already order by signtime desc. Get the first member.
					pulledItemInfo.SignTime = &orderInfoSlice[0].Signtime
					log.Debug("pulledItemInfo.SignTime:", pulledItemInfo.SignTime)
				}
			}
		}
		pulledItemInfos = append(pulledItemInfos, pulledItemInfo)
	}

	log.Debug(pulledItemInfos)

	return pulledItemInfos, err
}

func newPubTagHandler(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {

	log.Println(r.URL.Path, "(pub tag)")

	repo := ps.ByName("repo")
	item := ps.ByName("item")
	tag := ps.ByName("tag")
	log.Println("repo", repo, "item", item, "tag", tag) //log

	paras := ds.PubPara{}

	reqbody, err := ioutil.ReadAll(r.Body)
	if err != nil {
		log.Println("ioutil.ReadAll err:", err)
		JsonResult(w, http.StatusBadRequest, cmd.ErrorIOUtil, "Internal Error.", nil)
		return
	}
	err = json.Unmarshal(reqbody, &paras)
	if err != nil {
		log.Println("json.Unmarshal err:", err)
		JsonResult(w, http.StatusBadRequest, cmd.ErrorUnmarshal, "Internal Error.", nil)
		return
	}

	if !CheckLength(w, repo, MaxRepoLength) || !CheckLength(w, item, MaxItemLength) || !CheckLength(w, tag, MaxTagLength) {
		JsonResult(w, http.StatusOK, cmd.ErrorOutMaxLength, "repo or item or tag length out of max length.", nil)
		return
	}

	isExist, err := CheckItemExist(repo, item)
	if isExist == false {
		if paras.Datapool != "" && paras.ItemDesc != "" {
			isExist := CheckDataPoolExist(paras.Datapool)
			if isExist == false {
				JsonResult(w, http.StatusOK, cmd.ErrorDatapoolNotExits, "datapool not exist.", nil)
				return
			}
			url := DefaultServer + "/api/repositories/" + repo + "/" + item
			log.Println("daemon: connecting to ", url) //log

			req, err := http.NewRequest("GET", url, nil)
			if err != nil {
				log.Println("http.NewRequest err:", err)
				JsonResult(w, http.StatusBadRequest, cmd.InternalError, "Internal Error.", nil)
				return
			}
			resp, err := http.DefaultClient.Do(req)
			if err != nil {
				log.Println("http.DefaultClient.Do err:", err)
				JsonResult(w, http.StatusBadRequest, cmd.InternalError, "Internal Error.", nil)
				return
			}
			defer resp.Body.Close()

			respbody, err := ioutil.ReadAll(resp.Body)
			if err != nil {
				JsonResult(w, http.StatusBadRequest, cmd.InternalError, "Internal Error.", nil)
				return
			}

			result := ds.Result{}
			itemInfo := ds.ItemInfo{}
			result.Data = &itemInfo
			if resp.StatusCode == http.StatusOK {

				err = json.Unmarshal(respbody, &result)
				if err != nil {
					log.Println("json.Unmarshal err:", err)
					JsonResult(w, http.StatusBadRequest, cmd.InternalError, "Internal Error.", nil)
					return
				}
			} else {
				log.Println(string(respbody))
				err = json.Unmarshal(respbody, &result)
				if err != nil {
					log.Println("json.Unmarshal err:", err)
					JsonResult(w, http.StatusBadRequest, cmd.InternalError, "Internal Error.", nil)
					return
				}
				JsonResult(w, resp.StatusCode, result.Code, result.Msg, nil)
				return
			}

			err = InsertItemToDb(repo, item, paras.Datapool, paras.ItemDesc, itemInfo.Optime)
			if err != nil {
				log.Println("InsertItemToDb err:", err)
				JsonResult(w, http.StatusBadRequest, cmd.InternalError, "Internal Error.", nil)
				return
			}
		} else {
			JsonResult(w, http.StatusOK, cmd.ErrorItemNotExist, "item not been published.", nil)
			return
		}
	}

	//-------------------------------------------这是分割线-----------------------------------------------------

	dpconn, dptype, itemDesc, err := CheckTagAndGetDpPath(repo, item, tag)
	log.Println("CheckTagAndGetDpPath ret:", dpconn, dptype, itemDesc) //log
	if err != nil {
//.........这里部分代码省略.........

func HeartBeat() {
	getEp := false

	g_DaemonRole = GetDaemonRoleByPubRecord()

	for {
		if len(DaemonID) == 0 {
			log.Warn("No daemonid. You'd better start datahub with the parameter \"--token\".")
			return
		}

		heartbeatbody := Beatbody{Daemonid: DaemonID, Role: g_DaemonRole}
		if getEp == false && len(EntryPoint) == 0 {
			EntryPoint = getEntryPoint()
			getEp = true
		}
		if len(EntryPoint) != 0 {
			heartbeatbody.Entrypoint = append(heartbeatbody.Entrypoint, EntryPoint)
		}

		logQueue := logq.LogGetqueue()
		if len(logQueue) > 0 {
			heartbeatbody.Log = logQueue
		}

		errortags := checkErrortagsmap(&Errortagsmap)
		if len(errortags) != 0 {
			heartbeatbody.Errortag = errortags
		}

		heartbeatbody.CliEntrypoint = CLIEntrypoint + "?daemonauth=" + DaemonAuthrization

		jsondata, err := json.Marshal(heartbeatbody)
		if err != nil {
			l := log.Error(err)
			logq.LogPutqueue(l)
		}
		url := DefaultServerAPI + "/heartbeat"
		log.Trace("connecting to", url, string(jsondata))
		req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsondata))
		/*
			if len(loginAuthStr) > 0 {
				req.Header.Set("Authorization", loginAuthStr)
			}
		*/
		resp, err := http.DefaultClient.Do(req)
		if err != nil {
			l := log.Error(err)
			logq.LogPutqueue(l)
			time.Sleep(10 * time.Second)
			continue
		}

		defer resp.Body.Close()

		body, _ := ioutil.ReadAll(resp.Body)
		log.Tracef("HeartBeat http statuscode:%v,  http body:%s", resp.StatusCode, body)

		result := ds.Result{}
		result.Data = &Event{}
		if err := json.Unmarshal(body, &result); err == nil {
			if result.Code == 0 {
				EntryPointStatus = "available"
			} else {
				EntryPointStatus = "not available"
			}
		}
		if result.Data != nil && result.Data.(*Event).Type == TYPE_ITEM_DEL {
			deleteItemsAccordingToHeartbeat(body)
		}

		time.Sleep(heartbeatTimeout)
	}
}

func GetMessages() {
	log.Info("start GetMessages from messages server")
	var sleepInterval int
	var srtInterval string
	var e error
	url := DefaultServerAPI + "/notifications?forclient=1&type=item_event&status=0"
	for AutoPull == true {

		if srtInterval = os.Getenv("DATAHUB_MSG_INTERVAL"); len(srtInterval) > 0 {
			sleepInterval, e = strconv.Atoi(srtInterval)
			if e != nil {
				l := log.Error(e)
				logq.LogPutqueue(l)
			}
		} else {
			sleepInterval = 600
		}

		time.Sleep(time.Duration(sleepInterval) * time.Second)
		log.Debug("connecting to", url)
		req, err := http.NewRequest("GET", url, nil)

		if len(loginAuthStr) > 0 {
			req.Header.Set("Authorization", loginAuthStr)
		}

		resp, err := http.DefaultClient.Do(req)
		if err != nil {
			l := log.Error(err)
			logq.LogPutqueue(l)

			continue
		}
		defer resp.Body.Close()

		body, _ := ioutil.ReadAll(resp.Body)

		if resp.StatusCode == http.StatusOK {
			log.Debugf("HeartBeat http statuscode:%v,  http body:%s", resp.StatusCode, body)

			result := ds.Result{}
			Pages := ds.ResultPages{}
			MessagesSlice := []Messages{}
			Pages.Results = &MessagesSlice
			result.Data = &Pages

			if err := json.Unmarshal(body, &result); err == nil {
				if result.Code == 0 {
					log.Debug(result)
					for _, v := range MessagesSlice {
						if v.Type == "item_event" && v.Data.Event == TAGADDED {
							InsertToTagadded(v.Data.EventTime, v.Data.Repname, v.Data.Itemname, v.Data.Tag, NOTREAD)
						}
					}
				} else {
					l := log.Error("Get Messages errror:", result.Code)
					logq.LogPutqueue(l)
				}
			} else {
				log.Error(err)
			}

		} else if resp.StatusCode == http.StatusUnauthorized {
			log.Debug("not login", http.StatusUnauthorized)
			urllogin := DefaultServerAPI + "/"
			reql, err := http.NewRequest("GET", urllogin, nil)
			if len(loginBasicAuthStr) > 0 {
				reql.Header.Set("Authorization", loginBasicAuthStr)
				log.Info("user name:", gstrUsername)
			} else {
				log.Warn("not login")
				continue
			}

			respl, err := http.DefaultClient.Do(reql)
			if err != nil {
				log.Error(err)
				continue
			}
			defer respl.Body.Close()

			result := &ds.Result{}
			log.Println("login return", respl.StatusCode)
			if respl.StatusCode == 200 {
				body, _ := ioutil.ReadAll(respl.Body)
				log.Println(string(body))

				result.Data = &tk{}
				if err = json.Unmarshal(body, result); err != nil {
					log.Error(err)
					log.Println(respl.StatusCode, string(body))
					continue
				} else {
					loginAuthStr = "Token " + result.Data.(*tk).Token
					loginLogged = true
					log.Println(loginAuthStr)
				}
			}
		}
	}
//.........这里部分代码省略.........