func (gofetcher *Gofetcher) handler(method string, request *cocaine.Request, response *cocaine.Response) {
defer response.Close()
requestBody := <-request.Read()
httpRequest := gofetcher.ParseRequest(method, requestBody)
req, client, err := gofetcher.PrepareRequest(httpRequest)
if err != nil {
gofetcher.WriteError(response, httpRequest, err)
return
}
resp, err := gofetcher.ExecuteRequest(req, client, 1)
if err != nil {
gofetcher.WriteError(response, httpRequest, err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
gofetcher.WriteError(response, httpRequest, err)
return
}
gofetcher.WriteResponse(response, httpRequest, resp, body)
}
func dummy(request *cocaine.Request, response *cocaine.Response) {
logger := cocaine.NewLogger()
logger.Info("FROM HANDLER")
<-request.Read()
logger.Info("AFTER READ")
response.Write("Hello! I'm GO worker")
logger.Info("AFTER WRITE")
response.Close()
logger.Info("AFTER CLOSE")
}
func (gofetcher *Gofetcher) WriteError(response *cocaine.Response, request *Request, err error) {
if _, casted := err.(*WarnError); casted {
gofetcher.Logger.Warnf("Error occured: %v, while downloading %s",
err.Error(), request.URL)
} else {
gofetcher.Logger.Errf("Error occured: %v, while downloading %s",
err.Error(), request.URL)
}
response.Write([]interface{}{false, err.Error(), 0, http.Header{}})
}
func app_list(request *cocaine.Request, response *cocaine.Response) {
<-request.Read()
if list := <-storage.Find("apps", []string{"app"}); list.Err != nil {
logger.Err(fmt.Sprintf("Unable to fetch list%s", list.Err))
response.Write("fail")
response.Close()
} else {
response.Write(strings.Join(list.Res, ","))
response.Close()
}
}
func http_test(request *cocaine.Request, response *cocaine.Response) {
req := cocaine.UnpackProxyRequest(<-request.Read())
response.Write(cocaine.WriteHead(200, [][2]string{{"Content-Type", "text/html"}}))
ans := fmt.Sprintf("Method: %s, Uri: %s, UA: %s", req.Method, req.URL, req.UserAgent())
response.Write(ans)
response.Close()
}
func (gofetcher *Gofetcher) handler(method string, request *cocaine.Request, response *cocaine.Response) {
defer func() {
if r := recover(); r != nil {
var errMsg string
if err := r.(*error); err == nil {
errMsg = "Unknown error has occured."
} else {
errMsg = (*err).Error()
}
gofetcher.Logger.Errf("Error occured: %s.", errMsg)
response.ErrorMsg(PanicResponseErrorCode, errMsg)
}
response.Close()
}()
requestBody := <-request.Read()
httpRequest := gofetcher.ParseRequest(method, requestBody)
req, client, err := gofetcher.PrepareRequest(httpRequest)
if err != nil {
gofetcher.WriteError(response, httpRequest, err)
return
}
resp, err := gofetcher.ExecuteRequest(req, client, 1)
if err != nil {
gofetcher.WriteError(response, httpRequest, err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
gofetcher.WriteError(response, httpRequest, err)
return
}
gofetcher.WriteResponse(response, httpRequest, resp, body)
}
func handleTask(request *cocaine.Request, response *cocaine.Response) {
defer response.Close()
raw := <-request.Read()
var task tasks.ParsingTask
err := common.Unpack(raw, &task)
if err != nil {
response.ErrorMsg(-100, err.Error())
return
}
err = parsing.Parsing(ctxParsing, task)
if err != nil {
response.ErrorMsg(-100, err.Error())
} else {
response.Write("OK")
}
}
func common(request *cocaine.Request, response *cocaine.Response) {
defer response.Close()
<-request.Read()
if data, err := configmanager.GetCommonCfg(); err != nil {
response.ErrorMsg(-2, "Missing combaine.(yaml|json)")
} else {
response.Write(data)
}
}
func parsing(request *cocaine.Request, response *cocaine.Response) {
defer response.Close()
raw := <-request.Read()
name := string(raw)
if data, err := configmanager.GetParsingCfg(name); err != nil {
response.ErrorMsg(-2, fmt.Sprintf("Missing file with name %s", name))
} else {
response.Write(data)
}
}
func on_generate(request *cocaine.Request, response *cocaine.Response) {
defer response.Close()
inc := <-request.Read()
var task struct {
Text string
Size int
}
err := codec.NewDecoderBytes(inc, h).Decode(&task)
if err != nil {
response.ErrorMsg(-100, err.Error())
return
}
png, err := qenerate(task.Text)
if err != nil {
response.ErrorMsg(-200, err.Error())
return
}
response.Write(png)
}
func Send(request *cocaine.Request, response *cocaine.Response) {
defer response.Close()
raw := <-request.Read()
var task Task
err := common.Unpack(raw, &task)
if err != nil {
response.ErrorMsg(-100, err.Error())
return
}
if task.Config.Host == "" {
task.Config.Host, err = getCBBHost()
if err != nil {
response.ErrorMsg(-100, err.Error())
return
}
}
logger.Debugf("Task: %v", task)
cCli, err := cbb.NewCBBClient(&task.Config, task.Id)
if err != nil {
logger.Errf("Unexpected error %s", err)
response.ErrorMsg(-100, err.Error())
return
}
err = cCli.Send(task.Data, task.PrevTime)
if err != nil {
logger.Errf("Sending error %s", err)
response.ErrorMsg(-100, err.Error())
return
}
response.Write("DONE")
}
func on_http_generate(request *cocaine.Request, response *cocaine.Response) {
defer response.Close()
r, err := cocaine.UnpackProxyRequest(<-request.Read())
if err != nil {
response.ErrorMsg(-200, err.Error())
return
}
message := r.FormValue("message")
if len(message) == 0 {
response.Write(cocaine.WriteHead(http.StatusBadRequest, ErrorHeaders))
response.Write("Missing argument `message`")
return
}
png, err := qenerate(message)
if err != nil {
response.Write(cocaine.WriteHead(http.StatusInternalServerError, ErrorHeaders))
response.Write("Unable to generate QR")
return
}
response.Write(cocaine.WriteHead(http.StatusOK, OkHeaders))
response.Write(png)
}
func (gofetcher *Gofetcher) WriteResponse(response *cocaine.Response, request *Request, resp *http.Response, body []byte) {
response.Write([]interface{}{true, body, resp.StatusCode, resp.Header})
}
func on_ping(request *cocaine.Request, response *cocaine.Response) {
defer response.Close()
response.Write("gofetcher: ping reply")
}
func get(request *cocaine.Request, response *cocaine.Response) {
incoming := <-request.Read()
var inp struct {
Config map[string]interface{} "Config"
Task common.FetcherTask "Task"
}
err := common.Unpack(incoming, &inp)
if err != nil {
logger.Err(err)
response.ErrorMsg(1, fmt.Sprintf("%v", err))
response.Close()
return
}
url := CfgandTaskUrl(inp.Config, &inp.Task)
res, err := timetail.Get(url)
if err != nil {
response.ErrorMsg(1, fmt.Sprintf("%v", err))
response.Close()
return
}
response.Write(res)
response.Close()
}
func echo(request *cocaine.Request, response *cocaine.Response) {
inc := <-request.Read()
response.Write(inc)
response.Close()
}
func Send(request *cocaine.Request, response *cocaine.Response) {
raw := <-request.Read()
var task Task
err := common.Unpack(raw, &task)
if err != nil {
response.ErrorMsg(-100, err.Error())
return
}
logger.Debugf("%s Task: %v", task.Id, task)
task.Config.Id = task.Id
task.Config.Hosts, err = getAgaveHosts()
if err != nil {
response.ErrorMsg(-100, err.Error())
return
}
if len(task.Config.Fields) == 0 {
task.Config.Fields = DEFAULT_FIELDS
}
if task.Config.Step == 0 {
task.Config.Step = DEFAULT_STEP
}
logger.Debugf("%s Fields: %v Step: %d", task.Id, task.Config.Fields, task.Config.Step)
as, err := agave.NewAgaveSender(task.Config)
if err != nil {
logger.Errf("%s Unexpected error %s", task.Id, err)
response.ErrorMsg(-100, err.Error())
response.Close()
return
}
as.Send(task.Data)
response.Write("OK")
response.Close()
}