Beispiel #1
0
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)
}
Beispiel #2
0
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()
}
Beispiel #3
0
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")
}
Beispiel #4
0
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)
}
Beispiel #5
0
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()
}
Beispiel #6
0
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)
	}
}
Beispiel #7
0
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)
	}

}
Beispiel #8
0
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")
}
Beispiel #9
0
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()
	}
}
Beispiel #10
0
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")
	}
}
Beispiel #11
0
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()
}
Beispiel #12
0
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)
}
Beispiel #13
0
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)
}
Beispiel #14
0
func echo(request *cocaine.Request, response *cocaine.Response) {
	inc := <-request.Read()
	response.Write(inc)
	response.Close()
}