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 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 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 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 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
}
task.Config.Host, err = getRazladkiHost()
if err != nil {
response.ErrorMsg(-100, err.Error())
return
}
logger.Debugf("Task: %v", task)
rCli, err := razladki.NewRazladkiClient(&task.Config, task.Id)
if err != nil {
logger.Errf("Unexpected error %s", err)
response.ErrorMsg(-100, err.Error())
return
}
err = rCli.Send(task.Data, task.PrevTime)
if err != nil {
logger.Errf("Sending error %s", err)
response.ErrorMsg(-100, err.Error())
return
}
response.Write("DONE")
}
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 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 (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 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()
}