Esempio n. 1
0
func (this ImageRequest) DownloadZip(r *request.LoadZipRequest) (response.LoadZipResponse, util.Error) {
	t := "ParamInvalid"
	if len(r.Files.LoadFiles) < 1 {
		util.LogEvent(this.Cat, t, "NoLoadFiles", nil)
		return response.LoadZipResponse{}, util.Error{IsNormal: true, Err: errors.New("No files in request"), Type: "NoFilesInRequest"}
	}
	files := make(map[string][]byte)
	for _, file := range r.Files.LoadFiles {
		name := path.Base(strings.Replace(file.FilePath, "\\", "/", -1))
		if len(file.Rename) > 0 {
			name = file.Rename + path.Ext(file.FilePath)
		}
		storage, e := this.getStorageBySource(file.FilePath, file.IsSource)
		if e.Err != nil {
			return response.LoadZipResponse{}, e
		}
		util.LogEvent(this.Cat, "DownloadZip", this.GetChannel(file.FilePath), map[string]string{"uri": file.FilePath})
		bts, e := storage.Download()
		if e.Err != nil {
			return response.LoadZipResponse{}, e
		}
		files[name] = bts
	}
	bts, e := util.Zip(files)
	if e.Err != nil {
		return response.LoadZipResponse{}, e
	}
	bts = []byte(soapparse.B64.EncodeToString(bts))
	return response.LoadZipResponse{FileBytes: bts}, util.Error{}
}
Esempio n. 2
0
func (this ImageRequest) checkSaveCheckItem(r *request.SaveRequest) util.Error {
	t := "CheckFail"
	//if r.CheckItem == nil {
	//	return util.Error{}
	//}
	if r.CheckItem.IsOtherImage {
		if !isSvg(r.FileBytes) {
			util.LogEvent(this.Cat, t, "FormatInvalid", map[string]string{"detail": "image isn't svg!"})
			return util.Error{IsNormal: true, Err: errors.New("image isn't svg!"), Type: t}
		}
	} else {
		img, _, err := image.Decode(bytes.NewReader(r.FileBytes))
		if err != nil {
			util.LogEvent(this.Cat, t, "FormatInvalid", map[string]string{"detail": err.Error()})
			return util.Error{IsNormal: true, Err: err, Type: t}
		}
		//todo check img format
		if r.CheckItem.MinWidth > 0 && r.CheckItem.MinWidth > img.Bounds().Dx() {
			util.LogEvent(this.Cat, t, "LessMinWidth", map[string]string{"detail": util.JoinString("MinWidth:"+strconv.Itoa(r.CheckItem.MinWidth), " ImageWidth:", strconv.Itoa(img.Bounds().Dx()))})
			return util.Error{IsNormal: true, Err: errors.New("image width is less minwidth!"), Type: t}
		}
		if r.CheckItem.MinHeight > 0 && r.CheckItem.MinHeight > img.Bounds().Dy() {
			util.LogEvent(this.Cat, t, "LessMinHeight", map[string]string{"detail": util.JoinString("MinHeight:"+strconv.Itoa(r.CheckItem.MinHeight), " ImageHeight:", strconv.Itoa(img.Bounds().Dy()))})
			return util.Error{IsNormal: true, Err: errors.New("image heigth is less minheight!"), Type: t}
		}
	}
	if r.CheckItem.MaxBytes > 0 && int(r.CheckItem.MaxBytes) < len(r.FileBytes) {
		util.LogEvent(this.Cat, t, "BeyondMaxSize", map[string]string{"detail": util.JoinString("MaxSize:"+strconv.Itoa(int(r.CheckItem.MaxBytes)), " ImageSize:", strconv.Itoa(len(r.FileBytes)))})
		return util.Error{IsNormal: true, Err: errors.New("image size beyond max size"), Type: t}
	}
	return util.Error{Err: nil, IsNormal: true}
}
Esempio n. 3
0
func (h *ImageProcessHandler) recUrlEvt(c cat.Cat, imagePath string, r *http.Request) {
	util.LogEvent(c, "URL", "URL.Method", map[string]string{
		"Http": fmt.Sprintf("%s %s", r.Method, imagePath),
	})

	util.LogEvent(c, "image", fmt.Sprintf("%s:%d", util.LocalIP(), h.listenPort), nil)

	util.LogEvent(c, "URL", "URL.Client", map[string]string{
		"clientip": util.HttpClietIP(r),
		"serverip": util.LocalIP(),
		"proto":    r.Proto,
		"referer":  r.Referer(),
	})
}
Esempio n. 4
0
func View(this *ViewController, loadImgRequest *request.LoadImgRequest) {
	var result = util.Error{}
	Cat := cat.Instance()
	title := "/fdupload/target"
	if loadImgRequest.IsSource {
		title = "/fdupload/source"
	}
	tran := Cat.NewTransaction("URL", title)
	defer func() {
		if p := recover(); p != nil {
			Cat.LogPanic(p)
		}
		if result.Err != nil {
			tran.SetStatus(result.Err)
		} else {
			tran.SetStatus("0")
		}
		tran.Complete()
	}()
	util.LogEvent(Cat, "URL", "URL.Client", map[string]string{
		"clientip": util.GetClientIP(this.Ctx.Request),
		"serverip": util.GetIP(),
		"proto":    this.Ctx.Request.Proto,
		"referer":  this.Ctx.Request.Referer(),
		//"agent":    request.UserAgent(),
	})
	util.LogEvent(Cat, "URL", "URL.Method", map[string]string{
		"Http": this.Ctx.Request.Method + " " + loadImgRequest.FilePath,
	})

	imgRequest := business.ImageRequest{}
	imgRequest.Cat = Cat
	resp, e := imgRequest.Download(loadImgRequest)

	if e.Err != nil {
		this.Ctx.WriteString(e.Err.(error).Error())
	} else {
		//this.Ctx.Output.ContentType("image/Jpeg")

		//this.Ctx.Output.Body(resp.FileBytes)
		bts, err := soapparse.B64.DecodeString(string(resp.FileBytes))
		if err != nil {
			this.Ctx.WriteString(err.Error())
		} else {
			this.Ctx.Output.Header("Content-Type", "image/jpeg")
			this.Ctx.Output.Body(bts)
		}
	}
}
Esempio n. 5
0
func (this *NfsStorage) Download() ([]byte, util.Error) {
	var (
		bts []byte
		err error
	)
	var messagesize int
	if this.Cat != nil {
		tran := this.Cat.NewTransaction(CATTITLE, "Nfs.Download")
		tran.AddData("path", this.Path)
		defer func() {
			if err != nil {
				tran.SetStatus(err)
			} else {
				util.LogEvent(this.Cat, "Size", util.GetImageSizeDistribution(messagesize), map[string]string{"size": strconv.Itoa(messagesize)})
				tran.SetStatus("0")
			}
			tran.Complete()
		}()
	}
	bts, err = ioutil.ReadFile(this.Path)
	if err != nil {
		util.LogErrorEvent(this.Cat, ERRORTYPE_NFSDOWNLOADERR, err.Error())
		return []byte{}, util.Error{IsNormal: false, Err: err, Type: ERRORTYPE_NFSDOWNLOADERR}
	}
	messagesize = len(bts)
	return bts, util.Error{}
}
Esempio n. 6
0
func (this *FdfsStorage) Download() ([]byte, util.Error) {
	if e := this.initFdfsClient(); e.Err != nil {
		return nil, e
	}
	var (
		bts    []byte
		err    error
		result = util.Error{}
	)
	var messagesize int
	if this.Cat != nil {
		tran := this.Cat.NewTransaction(CATTITLE, "Fdfs.Download")
		tran.AddData("path", this.Path)
		defer func() {
			if result.Err != nil && result.IsNormal {
				tran.SetStatus(result.Err)
			} else {
				util.LogEvent(this.Cat, "Size", util.GetImageSizeDistribution(messagesize), map[string]string{"size": strconv.Itoa(messagesize)})
				tran.SetStatus("0")
			}
			tran.Complete()
		}()
	}
	bts, err = fdfsClient.DownloadToBuffer(this.Path, this.Cat)
	if err != nil {
		util.LogErrorEvent(this.Cat, ERRORTYPE_FDFSDOWNLOADERR, err.Error())
		result = util.Error{IsNormal: false, Err: err, Type: ERRORTYPE_FDFSDOWNLOADERR}
		return []byte{}, result
	}
	messagesize = len(bts)
	return bts, result
}
Esempio n. 7
0
func (m *Master) recRebootEvt() {
	cat := cat.Instance()
	tran := cat.NewTransaction("System", "Reboot")
	defer func() {
		tran.SetStatus("0")
		tran.Complete()
	}()
	util.LogEvent(cat, "Reboot", util.JoinString(util.GetIP(), ":", strconv.Itoa(m.port)), nil)
}
Esempio n. 8
0
func (this ImageRequest) checkSaveRequest(r *request.SaveRequest) util.Error {
	t := "ParamInvalid"
	if r.Channel == "" {
		util.LogEvent(this.Cat, t, "ChannelEmpty", nil)
		return util.Error{IsNormal: true, Err: errors.New("Channel can't be empty"), Type: t}
	}
	if r.FileBytes == nil || len(r.FileBytes) < 1 {
		util.LogEvent(this.Cat, t, util.JoinString(r.Channel, "-FileBytesEmpty"), nil)
		return util.Error{IsNormal: true, Err: errors.New("FileBytes can't be empty"), Type: t}
	}
	channel := models.Channel{Cat: this.Cat}
	channels, err := channel.GetAll()
	if err.Err != nil {
		return err
	}
	_, exists := channels[r.Channel]
	if !exists {
		util.LogEvent(this.Cat, t, util.JoinString(r.Channel, "-NoRegister"), nil)
		return util.Error{IsNormal: true, Err: errors.New(util.JoinString("channel[", r.Channel, "] isn't register!")), Type: t}
	}
	return util.Error{}
}
Esempio n. 9
0
func (this *ImageIndex) ParseName(imgName string) util.Error {
	imageName := this.DropExtension(imgName)
	if len(imageName) != NEWIMAGENAMELENGTH {
		util.LogEvent(this.Cat, ERRTYPE_IMAGENAMEINVALID, "LengthInvalid", nil)
		return util.Error{IsNormal: true, Err: errors.New("imagename length is invalid"), Type: ERRTYPE_IMAGENAMEINVALID}
	}
	swithoutcompute := util.Substr(imageName, 0, NEWIMAGENAMELENGTH-4)
	scompute := util.Substr(imageName, NEWIMAGENAMELENGTH-4, 4)
	if util.Compute(swithoutcompute) != scompute {
		util.LogEvent(this.Cat, ERRTYPE_IMAGENAMEINVALID, "ComputeFail", nil)
		return util.Error{IsNormal: true, Err: errors.New("Compute check faile."), Type: ERRTYPE_IMAGENAMEINVALID}
	}
	channelCode := util.Substr(imageName, 0, 2)

	tableZone, err := strconv.ParseInt(util.Substr(imageName, 2, 2), 36, 10)
	if err != nil {
		util.LogEvent(this.Cat, ERRTYPE_IMAGENAMEINVALID, "TableZoneInvalid", nil)
		return util.Error{IsNormal: true, Err: errors.New("tablezone is invalid."), Type: ERRTYPE_IMAGENAMEINVALID}
	}
	partitionKey, err := strconv.ParseInt(util.Substr(imageName, 4, 2), 36, 10)
	if err != nil {
		util.LogEvent(this.Cat, ERRTYPE_IMAGENAMEINVALID, "PartitionInvalid", nil)
		return util.Error{IsNormal: true, Err: errors.New("partition is invalid."), Type: ERRTYPE_IMAGENAMEINVALID}
	}
	version := util.Substr(imageName, 6, 1)
	idx, err := strconv.ParseInt(util.Substr(imageName, 7, 10), 36, 10)
	if err != nil {
		util.LogEvent(this.Cat, ERRTYPE_IMAGENAMEINVALID, "IndexInvalid", nil)
		return util.Error{IsNormal: true, Err: errors.New("index is invalid."), Type: ERRTYPE_IMAGENAMEINVALID}
	}
	this.ChannelCode = channelCode
	this.Id = idx
	this.PartitionKey = int16(partitionKey)
	this.TableZone = int(tableZone)
	this.Version = version
	return util.Error{}
}
Esempio n. 10
0
func (this ImageRequest) Download(r *request.LoadImgRequest) (response.LoadImgResponse, util.Error) {
	storage, e := this.getStorageBySource(r.FilePath, r.IsSource)
	if e.Err != nil {
		return response.LoadImgResponse{}, e
	}

	util.LogEvent(this.Cat, "Download", this.GetChannel(r.FilePath), map[string]string{"uri": r.FilePath})

	bts, e := storage.Download()
	if e.Err != nil {
		return response.LoadImgResponse{}, e
	}
	bts = []byte(soapparse.B64.EncodeToString(bts))
	return response.LoadImgResponse{FileBytes: bts}, util.Error{}
}
Esempio n. 11
0
func (w *ImageProcessWorker) Start(opt StartOpt) <-chan error {
	if !opt.NewHosting {
		opts := &web.ImageProcessOptions{ListenAddress: fmt.Sprintf("127.0.0.1:%d", w.Port)}
		webHandler := web.NewImageProcessWebHandler(opts)
		util.LogEvent(cat.Instance(), "Reboot", fmt.Sprintf("%s:%d", util.LocalIP(), w.Port), nil)
		go webHandler.Run()
		return webHandler.ListenError()
	} else {
		cmd := exec.Command("go", "run", "imgsvrd.go", "-process.worker", "-port", strconv.Itoa(w.Port))
		err := cmd.Start()
		if err != nil {
			log.Errorf("start worker=%d failed. error=%s", w.Port, err.Error())
			util.LogErrorEvent(cat.Instance(), "DaemonProcess.StartWorkerError", err.Error())
			w.startErrCh <- err
		}
	}
	return w.startErrCh
}
Esempio n. 12
0
func (this *ImageIndex) GetStorage() util.Error {
	if this.Id < 1 || this.TableZone < 1 || this.PartitionKey < 1 {
		util.LogErrorEvent(this.Cat, ERRTYPE_GETIMAGEINDEX, "Parameter is Invalid")
		return util.Error{IsNormal: true, Err: errors.New("getimageindex parameters is invalid"), Type: ERRTYPE_GETIMAGEINDEX}
	}
	var result util.Error = util.Error{}
	if this.Cat != nil {
		tran := this.Cat.NewTransaction(DBTITLE, "ImageIndex.GetStorage")
		defer func() {
			if result.Err != nil {
				tran.SetStatus(result.Err)
			} else {
				tran.SetStatus("0")
			}
			tran.AddData("TabeZone", strconv.Itoa(this.TableZone))
			tran.AddData("Id", strconv.FormatInt(this.Id, 10))
			tran.AddData("PartitionKey", strconv.Itoa(int(this.PartitionKey)))
			tran.Complete()
		}()
	}

	o := orm.NewOrm()
	o.Using(getDBString(this.TableZone))
	res := make(orm.Params)
	nums, err := o.Raw(util.JoinString("SELECT storagepath,storagetype FROM imageindex_", strconv.Itoa(this.TableZone), " WHERE id=? AND partitionKey=?"), this.Id, this.PartitionKey).RowsToMap(&res, "storagepath", "storagetype")
	if err != nil {
		util.LogErrorEvent(this.Cat, ERRTYPE_GETIMAGEINDEX, err.Error())
		result = util.Error{IsNormal: false, Err: err, Type: ERRTYPE_GETIMAGEINDEX}
		return result
	}
	if nums < 1 {
		util.LogEvent(this.Cat, ERRTYPE_IMAGENAMEINVALID, "IdNoFound", nil)
		result = util.Error{IsNormal: true, Err: errors.New("image id is't exists"), Type: ERRTYPE_IMAGENAMEINVALID}
		return result
	}
	for k, v := range res {
		this.StoragePath = k
		this.StorageType = fmt.Sprintf("%v", v)
	}
	return result
}
Esempio n. 13
0
func (this *FdfsStorage) Upload(bts []byte, fileExt string) (string, util.Error) {
	if e := this.initFdfsClient(); e.Err != nil {
		return "", e
	}
	config := models.Config{Cat: this.Cat}
	groups, e := config.GetGroups()
	if e.Err != nil {
		return "", e
	}
	if uploadcount == 99999999 {
		uploadcount = 0
	}
	i := uploadcount % len(groups)
	uploadcount = 0
	g := groups[i]

	var result util.Error = util.Error{}
	if this.Cat != nil {
		tran := this.Cat.NewTransaction(CATTITLE, "Fdfs.Upload")
		util.LogEvent(this.Cat, "Size", util.GetImageSizeDistribution(len(bts)), map[string]string{"size": strconv.Itoa(len(bts))})

		defer func() {
			if result.Err != nil && result.IsNormal {
				tran.SetStatus(result.Err)
			} else {
				tran.SetStatus("0")
			}
			tran.Complete()
		}()
	}
	path, err := fdfsClient.UploadByBuffer(g, bts, fileExt)
	if err != nil {
		util.LogErrorEvent(this.Cat, ERRORTYPE_FDFSUPLOADERR, err.Error())
		result = util.Error{IsNormal: false, Err: err, Type: ERRORTYPE_FDFSUPLOADERR}
		return "", result
	}
	return path, result
}
Esempio n. 14
0
func (this ImageRequest) Save(r *request.SaveRequest) (response.SaveResponse, util.Error) {
	r.TargetFormat = strings.ToLower(r.TargetFormat)
	r.Channel = strings.ToLower(r.Channel)
	util.LogEvent(this.Cat, "Save", r.Channel, nil)

	this.checkPlanID(r)
	if err := this.checkSaveRequest(r); err.Err != nil {
		return response.SaveResponse{}, err
	}
	if err := this.checkSaveCheckItem(r); err.Err != nil {
		return response.SaveResponse{}, err
	}
	storage, storageType := NewStorage(this.Cat)
	path, e := storage.Upload(r.FileBytes, r.TargetFormat)
	if e.Err != nil {
		return response.SaveResponse{}, e
	}
	tableZone := sharding()
	channel := models.Channel{Cat: this.Cat}
	imgIndex := models.ImageIndex{ChannelCode: channel.GetChannelCode(r.Channel), StoragePath: path, StorageType: storageType, TableZone: tableZone, Cat: this.Cat}
	plan := ""
	if r.Process.AnyTypes != nil && len(r.Process.AnyTypes) > 0 {
		bts, err := r.Process.MarshalJSON()
		if err != nil {
			util.LogErrorEvent(this.Cat, ERRORTYPE_MARSHALJSON, err.Error())
			return response.SaveResponse{}, util.Error{IsNormal: false, Err: err, Type: ERRORTYPE_MARSHALJSON}
		}
		plan = string(bts)
	}

	if e := imgIndex.SaveToDB(plan); e.Err != nil {
		return response.SaveResponse{}, e
	}
	uri := imgIndex.GetImageName()
	return response.SaveResponse{CheckPass: true, OriginalPath: uri, TargetPath: uri}, util.Error{}
}
Esempio n. 15
0
func (this ImageRequest) Delete(r *request.DeleteRequest) (response.DeleteResponse, util.Error) {
	storage, e := this.getStorage(r.FilePath)
	if e.Err != nil {
		return response.DeleteResponse{}, e
	}
	util.LogEvent(this.Cat, "Delete", this.GetChannel(r.FilePath), map[string]string{"uri": r.FilePath, "IsDeleteAll": strconv.FormatBool(r.IsDeleteAll)})

	if isNewUri(r.FilePath) {
		imgIndex := models.ImageIndex{Cat: this.Cat}
		e = imgIndex.ParseName(r.FilePath)
		if e.Err != nil {
			return response.DeleteResponse{}, e
		}
		e = imgIndex.Delete()
		if e.Err != nil {
			return response.DeleteResponse{}, e
		}
	}
	e = storage.Delete(r.IsDeleteAll)
	if e.Err != nil {
		return response.DeleteResponse{}, e
	}
	return response.DeleteResponse{}, util.Error{}
}
Esempio n. 16
0
func (handler *ImageWS) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	defer r.Body.Close()
	w.Header().Set("Connection", "keep-alive")
	w.Header().Set("Content-Type", "text/xml")

	Cat := cat.Instance()
	tran := Cat.NewTransaction("URL", "ImageWs.asmx")
	util.LogEvent(Cat, "URL", "URL.Client", map[string]string{
		"clientip": util.GetClientIP(r),
		"serverip": util.GetIP(),
		"proto":    r.Proto,
		"referer":  r.Referer(),
		//"agent":    request.UserAgent(),
	})
	var result util.Error
	defer func() {
		if p := recover(); p != nil {
			Cat.LogPanic(p)
		}
		if result.Err != nil && !result.IsNormal {
			tran.SetStatus(result.Err)

		} else {
			tran.SetStatus("0")
		}
		tran.Complete()
	}()
	bts, err := ioutil.ReadAll(r.Body)
	if err != nil {
		util.LogErrorEvent(Cat, "RequestReadError", err.Error())
		result = util.Error{IsNormal: false, Err: err, Type: "RequestReadError"}
		msg := []byte(err.Error())
		writeResponse(w, msg)
		return
	}
	req := request.Request{}
	result = EncodeRequest(Cat, bts, &req)
	if result.Err != nil && !result.IsNormal {
		writeResponse(w, []byte(result.Type))
		return
	}
	var (
		resp       interface{}
		header     *response.Header
		e          util.Error
		imgRequest = business.ImageRequest{Cat: Cat}
	)

	requestTran := Cat.NewTransaction("Request", strings.Replace(req.Header.RequestType, "Arch.Base.ImageWS.", "", -1))
	defer func() {
		if p := recover(); p != nil {
			Cat.LogPanic(p)
		}
		if result.Err != nil && !result.IsNormal {
			requestTran.SetStatus(result.Err)
		} else {
			requestTran.SetStatus(CATTRANSUCCESS)
		}
		requestTran.Complete()
	}()

	switch req.Header.RequestType {
	case REQUESTTYPE_SAVEIMAGE:
		resp, e = imgRequest.Save(&req.SaveRequest)
	case REQUESTTYPE_LOADIMAGE:
		resp, e = imgRequest.Download(&req.LoadImgRequest)
	case REQUESTTYPE_LOADZIP:
		resp, e = imgRequest.DownloadZip(&req.LoadZipRequest)
	case REQUESTTYPE_DELETEIMAGE:
		resp, e = imgRequest.Delete(&req.DeleteRequest)
	default:
		util.LogErrorEvent(Cat, "RequestTypeInvalid", req.Header.RequestType)
		e = util.Error{IsNormal: true, Err: errors.New("requesttype is invalid!"), Type: "RequestTypeInvalid"}
	}
	if e.Err != nil {
		result = e
		header = createFailHeader(req.Header, fmt.Sprintf("%v", e.Err))
	} else {
		header = transformHeader(req.Header, RESULTCODE_SUCCESS, "")
	}
	content, e := DecodeResponse(Cat, header, resp)
	if e.Err != nil {
		result = e
		writeResponse(w, []byte(result.Err.(error).Error()))
	} else {
		writeResponse(w, content)
	}
}
Esempio n. 17
0
func (handler *LogoWS) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	Cat := cat.Instance()
	w.Header().Set("Connection", "keep-alive")
	w.Header().Set("Content-Type", "text/xml")

	tran := Cat.NewTransaction("URL", "LogoWs.asmx")
	util.LogEvent(Cat, "URL", "URL.Client", map[string]string{
		"clientip": util.GetClientIP(r),
		"serverip": util.GetIP(),
		"proto":    r.Proto,
		"referer":  r.Referer(),
		//"agent":    request.UserAgent(),
	})
	var result util.Error
	defer func() {
		if p := recover(); p != nil {
			Cat.LogPanic(p)
		}
		if result.Err != nil && !result.IsNormal {
			tran.SetStatus(result.Err)
		} else {
			tran.SetStatus("0")
		}
		tran.Complete()
	}()

	bts, err := ioutil.ReadAll(r.Body)
	if err != nil {
		util.LogErrorEvent(Cat, "RequestReadError", err.Error())
		result = util.Error{IsNormal: false, Err: err, Type: "RequestReadError"}

		return
	}
	req := request.Request{}
	result = EncodeRequest(Cat, bts, &req)
	if result.Err != nil && !result.IsNormal {
		//writeResponse(w, []byte(result.Type))
		return
	}

	var (
		resp        interface{}
		header      *response.Header
		e           util.Error
		logoRequest = business.LogoRequest{
			ImageRequest: business.ImageRequest{
				Cat: Cat,
			},
			FontSizes: []int{14, 16, 18, 20},
		}
	)

	requestTran := Cat.NewTransaction("Request", "SaveLogo")
	defer func() {
		if p := recover(); p != nil {
			Cat.LogPanic(p)
		}
		if result.Err != nil && !result.IsNormal {
			requestTran.SetStatus(result.Err)
		} else {
			requestTran.SetStatus("0")
		}
		requestTran.Complete()
	}()

	resp, result = logoRequest.Save(&req.SaveRequest)

	if result.Err != nil {
		header = createFailHeader(req.Header, fmt.Sprintf("%v", result.Err))
	} else {
		header = transformHeader(req.Header, RESULTCODE_SUCCESS, "")
	}
	content, e := DecodeResponse(Cat, header, resp)
	if e.Err != nil {
		result = e
		writeResponse(w, []byte(result.Err.(error).Error()))
	} else {
		writeResponse(w, content)
	}

	//content, err := soapparse.DecResp(header, resp) //
	//if err != nil {
	//	return
	//}
	//writeResponse(w, content)
}