func (p *ScaleProcessor) Process(img *img4g.Image) error {
log.Debug("process scale")
var err error
tran := cat.Instance().NewTransaction("Command", "Scale")
defer func() {
tran.SetStatus(err)
tran.Complete()
}()
err = img.Resize(p.Width, p.Height)
return err
}
func TestDownloadToBuffer(t *testing.T) {
trackerIp := []string{"10.2.25.31"}
trackerPort := "22122"
fdfsClient, err := NewFdfsClient(trackerIp, trackerPort)
if err != nil {
t.Error(err)
}
catInstance := cat.Instance()
b, err := fdfsClient.DownloadToBuffer("group1/M00/18/91/CgIZH1RyormAP7xTAAA1U2y_hqk858.jpg", catInstance)
if err != nil {
t.Error(err)
}
ioutil.WriteFile("download.jpg", b, os.ModePerm)
}
func (this *HostProcessor) Run() {
hostPort = strconv.Itoa(this.Port)
threadcount := strconv.Itoa(this.ThreadCount)
log.WithFields(log.Fields{
"hostPort": hostPort,
"threadCount": threadcount,
"nginxPath": this.NginxPath,
"nginxPort": this.NginxPort,
}).Debug("run host process")
defer func() {
if p := recover(); p != nil {
log.WithFields(log.Fields{
"hostPort": hostPort,
"threadCount": threadcount,
"type": "DaemonProcess.RunPanic",
}).Error(fmt.Sprintf("%v", p))
LogErrorEvent(CatInstance, "DaemonProcess.RunPanic", fmt.Sprintf("%v", p))
}
os.Exit(2)
}()
func() {
Cat := cat.Instance()
tran := Cat.NewTransaction("System", Reboot)
defer func() {
tran.SetStatus("0")
tran.Complete()
}()
LogEvent(Cat, Reboot, JoinString(GetIP(), ":", hostPort), nil)
}()
this.computePorts()
if this.NginxPath != "" {
if err := ModifyNginxconf(this.NginxPath, this.NginxPort, ports); err != nil {
log.WithFields(log.Fields{
"nginxPath": this.NginxPath,
"nginxPort": this.NginxPort,
"type": "DaemonProcess.ModifyNginxError",
}).Error(err.Error())
LogErrorEvent(CatInstance, "DaemonProcess.ModifyNginxError", err.Error())
return
}
if err := RestartNginx(this.NginxPath); err != nil {
log.WithFields(log.Fields{
"nginxPath": this.NginxPath,
"type": "DaemonProcess.RestartNginxError",
}).Error(err.Error())
LogErrorEvent(CatInstance, "DaemonProcess.RestartNginxError", err.Error())
return
}
}
portstats = make(map[string]url.Values)
for p, _ := range ports {
this.startWorkerProcess(p)
log.WithFields(log.Fields{
"port": p,
}).Debug("run subproccess on port")
}
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt, os.Kill)
go this.monitorWorkerProcesses()
go this.sendCatHeartBeat()
go this.listenHeartbeat()
<-c //Interupt signal coming
os.Exit(0)
}
func (this *HostProcessor) sendCatHeartBeat() {
defer func() {
if err := recover(); err != nil {
log.Error(fmt.Sprintf("%v", err))
this.sendCatHeartBeat()
}
}()
ip := GetIP()
second := time.Now().Second()
if second < 29 {
sleep := time.Duration((29 - second) * 1000000000)
time.Sleep(sleep)
}
catinstance := cat.Instance()
for {
log.Debug("send cat heartbeat")
stats1 := GetStatus()
data := url.Values{}
data.Add("port", hostPort)
for k, v := range stats1 {
data.Add(k, v)
}
portstats[hostPort] = data
tran := catinstance.NewTransaction("System", "Status")
h := catinstance.NewHeartbeat("HeartBeat", ip)
for _, heart := range portstats {
if heart == nil {
continue
}
port := heart.Get("port")
if port == "" {
continue
}
h.Set("System", JoinString("Alloc_", port), heart.Get("Alloc"))
h.Set("System", JoinString("TotalAlloc_", port), heart.Get("TotalAlloc"))
h.Set("System", JoinString("Sys_", port), heart.Get("Sys"))
h.Set("System", JoinString("Mallocs_", port), heart.Get("Mallocs"))
h.Set("System", JoinString("Frees_", port), heart.Get("Frees"))
h.Set("System", JoinString("OtherSys_", port), heart.Get("OtherSys"))
h.Set("System", JoinString("PauseNs_", port), heart.Get("PauseNs"))
h.Set("HeapUsage", JoinString("HeapAlloc_", port), heart.Get("HeapAlloc"))
h.Set("HeapUsage", JoinString("HeapSys_", port), heart.Get("HeapSys"))
h.Set("HeapUsage", JoinString("HeapIdle_", port), heart.Get("HeapIdle"))
h.Set("HeapUsage", JoinString("HeapInuse_", port), heart.Get("HeapInuse"))
h.Set("HeapUsage", JoinString("HeapReleased_", port), heart.Get("HeapReleased"))
h.Set("HeapUsage", JoinString("HeapObjects_", port), heart.Get("HeapObjects"))
h.Set("GC", JoinString("NextGC_", port), heart.Get("NextGC"))
h.Set("GC", JoinString("LastGC_", port), heart.Get("LastGC"))
h.Set("GC", JoinString("NumGC_", port), heart.Get("NumGC"))
portstats[port] = nil
}
h.SetStatus("0")
h.Complete()
tran.SetStatus("0")
tran.Complete()
second = time.Now().Second()
sleep := time.Duration((90 - second) * 1000000000)
time.Sleep(sleep)
}
}
func (handler *Handler) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
Cat := cat.Instance()
handler.ChainBuilder = &ProcChainBuilder{Cat}
uri := request.URL.String()
tran := Cat.NewTransaction("URL", getShortUri(uri))
var (
err error
isSuccess bool = true
)
defer func() {
p := recover()
if p != nil {
logErrWithUri(uri, fmt.Sprintf("%v", p), "errorLevel")
Cat.LogPanic(p)
tran.SetStatus(p)
}
if isSuccess {
tran.SetStatus("0")
tran.Complete()
} else {
tran.SetStatus(err)
tran.Complete()
}
if p != nil || err != nil {
http.Error(writer, http.StatusText(404), 404)
}
}()
LogEvent(Cat, "URL", "URL.Client", map[string]string{
"clientip": GetClientIP(request),
"serverip": GetIP(),
"proto": request.Proto,
"referer": request.Referer(),
//"agent": request.UserAgent(),
})
LogEvent(Cat, "URL", "URL.Method", map[string]string{
"Http": request.Method + " " + uri,
})
LogEvent(Cat, "UpstreamProcess", JoinString(GetIP(), ":", WorkerPort), nil)
isDigimarkUrl := false
params, ok1 := legalUrl.FindStringSubmatchMap(uri)
if !ok1 {
params, ok1 = digimarkUrl.FindStringSubmatchMap(uri)
if ok1 {
isDigimarkUrl = true
} else {
err = errors.New("URI.ParseError")
logErrWithUri(uri, err.Error(), "warnLevel")
LogErrorEvent(Cat, "URI.ParseError", "")
return
}
}
//parse storage from url parameters
store, storagetype, err1 := FindStorage(params, Cat)
if err1 != nil {
err = errors.New("Storage.ParseError")
logErrWithUri(uri, err1.Error(), "warnLevel")
LogErrorEvent(Cat, "Storage.ParseError", err1.Error())
return
}
//parse handlers chain from url parameters
var chain *proc.ProcessorChain = nil
var buildErr *buildError = nil
if isDigimarkUrl == true {
chain, buildErr = handler.ChainBuilder.DigimarkProcChain(params)
} else {
chain, buildErr = handler.ChainBuilder.Build(params)
}
if buildErr != nil {
err = errors.New(buildErr.Type())
logErrWithUri(uri, buildErr.Error(), "warnLevel")
LogErrorEvent(Cat, buildErr.Type(), buildErr.Error())
return
}
//download image from storage
var bts []byte
func() {
type storageError interface {
Error() string
Normal() bool //is normal error?
Type() string //error type
}
var err1 error
getimagetran := Cat.NewTransaction("Storage", storagetype)
defer func() {
if err1 != nil {
logErrWithUri(uri, err1.Error(), "errorLevel")
e, ok := err1.(storageError)
if ok && e.Normal() {
err = errors.New(fmt.Sprintf("%v.%v", storagetype, e.Type()))
LogErrorEvent(Cat, fmt.Sprintf("%v.%v", storagetype, e.Type()), e.Error())
} else {
err = errors.New(storagetype + ".UnExpectedError")
LogErrorEvent(Cat, err.Error(), err1.Error())
isSuccess = false
}
} else if len(bts) == 0 {
err = errors.New(storagetype + ".ImgLenZero")
LogErrorEvent(Cat, err.Error(), "recv image length is 0")
logErrWithUri(uri, "recv image length is 0", "warnLevel")
}
if isSuccess {
getimagetran.SetStatus("0")
} else {
getimagetran.SetStatus(err)
}
getimagetran.Complete()
}()
bts, err1 = store.GetImage()
}()
if err != nil {
return
}
size := len(bts)
sizestr := strconv.Itoa(size)
tran.AddData("size", sizestr)
Cat.LogEvent("Size", GetImageSizeDistribution(size))
log.WithFields(log.Fields{
"size": size,
"uri": uri,
}).Debug("recv image length")
format, _ := params["ext"]
img := &img4g.Image{Blob: bts, Format: format, Cat: Cat}
rspChan := make(chan bool, 1)
task := &nepheleTask{inImg: img, chain: chain, rspChan: rspChan, CatInstance: Cat, canceled: false}
taskChan <- task
select {
case ok := <-rspChan:
if !ok {
err = errors.New("ProcessError")
isSuccess = false
logErrWithUri(uri, err.Error(), "errorLevel")
return
}
case <-time.After(time.Second * 5):
task.SetCanceled()
err = errors.New("ProcessTimeout")
logErrWithUri(uri, err.Error(), "errorLevel")
isSuccess = false
LogErrorEvent(Cat, "ProcessTimeout", "")
return
}
writer.Header().Set("Content-Type", "image/"+format)
writer.Header().Set("Content-Length", strconv.Itoa(len(img.Blob)))
writer.Header().Set("Last-Modified", "2015/1/1 01:01:01")
log.WithFields(log.Fields{
"size": size,
"uri": uri,
}).Debug("final image size")
if _, err1 = writer.Write(img.Blob); err1 != nil {
logErrWithUri(uri, err1.Error(), "errorLevel")
err = errors.New("Response.WriteError")
LogErrorEvent(Cat, "Response.Writeerror", err1.Error())
isSuccess = false
}
}
func init() {
util.InitCat()
CatInstance = cat.Instance()
}
