func (server *Server) buildArgumentsGravity(arguments *list.List, params imageserver.Params) error {
gravity, _ := params.GetString("gravity")
var translatedGravity string
if gravity != "" {
switch {
case gravity == "n":
translatedGravity = "North"
case gravity == "s":
translatedGravity = "South"
case gravity == "e":
translatedGravity = "East"
case gravity == "w":
translatedGravity = "West"
case gravity == "ne":
translatedGravity = "NorthEast"
case gravity == "se":
translatedGravity = "SouthEast"
case gravity == "nw":
translatedGravity = "NorthWest"
case gravity == "sw":
translatedGravity = "SouthWest"
}
if translatedGravity == "" {
return &imageserver.ParamError{Param: "gravity", Message: "gravity should n, s, e, w, ne, se, nw or sw"}
}
} else {
// Default gravity is center.
translatedGravity = "Center"
}
arguments.PushBack("-gravity")
arguments.PushBack(fmt.Sprintf("%s", translatedGravity))
return nil
}
func (server *Server) buildArgumentsCrop(arguments *list.List, params imageserver.Params) error {
if !params.Has("crop") {
return nil
}
crop, _ := params.GetString("crop")
cropArgs := strings.Split(crop, ",")
cropArgsLen := len(cropArgs)
if cropArgsLen != 2 && cropArgsLen != 4 {
return &imageserver.ParamError{Param: "crop", Message: "Invalid crop request, parameters number mismatch"}
}
if cropArgsLen == 2 {
width, _ := strconv.Atoi(cropArgs[0])
height, _ := strconv.Atoi(cropArgs[1])
arguments.PushBack("-crop")
arguments.PushBack(fmt.Sprintf("%dx%d", width, height))
arguments.PushBack("+repage")
}
if cropArgsLen == 4 {
width, _ := strconv.Atoi(cropArgs[0])
height, _ := strconv.Atoi(cropArgs[1])
x, _ := strconv.Atoi(cropArgs[2])
y, _ := strconv.Atoi(cropArgs[3])
arguments.PushBack("-crop")
arguments.PushBack(fmt.Sprintf("%dx%d+%d+%d", width, height, x, y))
arguments.PushBack("+repage")
}
return nil
}
func (prc *ResizeProcessor) getResampling(params imageserver.Params) (gift.Resampling, error) {
if !params.Has("resampling") {
if prc.DefaultResampling != nil {
return prc.DefaultResampling, nil
}
return gift.NearestNeighborResampling, nil
}
rsp, err := params.GetString("resampling")
if err != nil {
return nil, err
}
switch rsp {
case "nearest_neighbor":
return gift.NearestNeighborResampling, nil
case "box":
return gift.BoxResampling, nil
case "linear":
return gift.LinearResampling, nil
case "cubic":
return gift.CubicResampling, nil
case "lanczos":
return gift.LanczosResampling, nil
}
return nil, &imageserver.ParamError{Param: "resampling", Message: "invalid value"}
}
func (prc *Processor) getInterpolation(params imageserver.Params) (resize.InterpolationFunction, error) {
if !params.Has("interpolation") {
return prc.DefaultInterpolation, nil
}
interpolation, err := params.GetString("interpolation")
if err != nil {
return 0, err
}
switch interpolation {
case "nearest_neighbor":
return resize.NearestNeighbor, nil
case "bilinear":
return resize.Bilinear, nil
case "bicubic":
return resize.Bicubic, nil
case "mitchell_netravali":
return resize.MitchellNetravali, nil
case "lanczos2":
return resize.Lanczos2, nil
case "lanczos3":
return resize.Lanczos3, nil
default:
return 0, &imageserver.ParamError{Param: "interpolation", Message: "invalid value"}
}
}
func (srv *Server) getPath(params imageserver.Params) (string, error) {
src, err := params.GetString(imageserver_source.Param)
if err != nil {
return "", err
}
// This trick comes from net/http.Dir.Open().
// It allows to "jail" the path inside the root.
return filepath.Join(srv.Root, filepath.FromSlash(path.Clean("/"+src))), nil
}
func (prc *RotateProcessor) getBackground(params imageserver.Params) (color.Color, error) {
if !params.Has("background") {
return color.Transparent, nil
}
s, err := params.GetString("background")
if err != nil {
return nil, err
}
c, err := parseHexColor(s)
if err != nil {
return nil, &imageserver.ParamError{Param: "background", Message: err.Error()}
}
return c, nil
}
func TestParseQueryString(t *testing.T) {
req, err := http.NewRequest("GET", "http://localhost?string=foo", nil)
if err != nil {
t.Fatal(err)
}
params := imageserver.Params{}
ParseQueryString("string", req, params)
s, err := params.GetString("string")
if err != nil {
t.Fatal(err)
}
if s != "foo" {
t.Fatal("not equals")
}
}
// Parse implements Parser.
func (parser *FormatParser) Parse(req *http.Request, params imageserver.Params) error {
ParseQueryString("format", req, params)
if !params.Has("format") {
return nil
}
format, err := params.GetString("format")
if err != nil {
return err
}
if format == "jpg" {
format = "jpeg"
}
params.Set("format", format)
return nil
}
func parseSourceTransform(ps Parser, req *http.Request, params imageserver.Params, f func(string) string) error {
err := ps.Parse(req, params)
if err != nil {
return err
}
if !params.Has(imageserver.SourceParam) {
return nil
}
source, err := params.GetString(imageserver.SourceParam)
if err != nil {
return err
}
source = f(source)
params.Set(imageserver.SourceParam, source)
return nil
}
func (hdr *FallbackHandler) getHandler(im *imageserver.Image, params imageserver.Params) (imageserver.Handler, error) {
if im.Format != "gif" {
return hdr.Fallback, nil
}
if !params.Has("format") {
return hdr.Handler, nil
}
format, err := params.GetString("format")
if err != nil {
return nil, err
}
if format != "gif" {
return hdr.Fallback, nil
}
return hdr.Handler, nil
}
func getModeFunc(params imageserver.Params) (modeFunc, error) {
if !params.Has("mode") {
return resize.Resize, nil
}
mode, err := params.GetString("mode")
if err != nil {
return nil, err
}
switch mode {
case "resize":
return resize.Resize, nil
case "thumbnail":
return resize.Thumbnail, nil
default:
return nil, &imageserver.ParamError{Param: "mode", Message: "invalid value"}
}
}
func (prc *RotateProcessor) getInterpolation(params imageserver.Params) (gift.Interpolation, error) {
if !params.Has("interpolation") {
return prc.DefaultInterpolation, nil
}
interp, err := params.GetString("interpolation")
if err != nil {
return 0, err
}
switch interp {
case "nearest_neighbor":
return gift.NearestNeighborInterpolation, nil
case "linear":
return gift.LinearInterpolation, nil
case "cubic":
return gift.CubicInterpolation, nil
}
return 0, &imageserver.ParamError{Param: "interpolation", Message: "invalid value"}
}
func TestFormatParserParse(t *testing.T) {
parser := &FormatParser{}
req, err := http.NewRequest("GET", "http://localhost?format=jpg", nil)
if err != nil {
t.Fatal(err)
}
params := imageserver.Params{}
err = parser.Parse(req, params)
if err != nil {
t.Fatal(err)
}
format, err := params.GetString("format")
if err != nil {
t.Fatal(err)
}
if format != "jpeg" {
t.Fatal("not equals")
}
}
func TestSourceParserParse(t *testing.T) {
parser := &SourceParser{}
req, err := http.NewRequest("GET", "http://localhost?source=foo", nil)
if err != nil {
t.Fatal(err)
}
params := imageserver.Params{}
err = parser.Parse(req, params)
if err != nil {
t.Fatal(err)
}
source, err := params.GetString(imageserver.SourceParam)
if err != nil {
t.Fatal(err)
}
if source != "foo" {
t.Fatal("not equals")
}
}
func (srv *Server) doRequest(params imageserver.Params) (*http.Response, error) {
src, err := params.GetString(imageserver_source.Param)
if err != nil {
return nil, err
}
req, err := http.NewRequest("GET", src, nil)
if err != nil {
return nil, newSourceError(err.Error())
}
c := srv.Client
if c == nil {
c = http.DefaultClient
}
response, err := c.Do(req)
if err != nil {
return nil, newSourceError(err.Error())
}
return response, nil
}
func getEncoderFormat(defaultFormat string, params imageserver.Params) (Encoder, string, error) {
fromParams := false
format := defaultFormat
if params.Has("format") || defaultFormat == "" {
fromParams = true
var err error
format, err = params.GetString("format")
if err != nil {
return nil, "", err
}
}
enc, err := getEncoder(format)
if err != nil {
if fromParams {
err = &imageserver.ParamError{Param: "format", Message: err.Error()}
}
return nil, "", err
}
return enc, format, nil
}
func (prc *ResizeProcessor) getFilter(width, height int, params imageserver.Params) (gift.Filter, error) {
rsp, err := prc.getResampling(params)
if err != nil {
return nil, err
}
if !params.Has("mode") || width == 0 || height == 0 {
return gift.Resize(width, height, rsp), nil
}
mode, err := params.GetString("mode")
if err != nil {
return nil, err
}
switch mode {
case "fit":
return gift.ResizeToFit(width, height, rsp), nil
case "fill":
return gift.ResizeToFill(width, height, rsp, gift.CenterAnchor), nil
}
return nil, &imageserver.ParamError{Param: "mode", Message: "invalid value"}
}
func getSourceURL(params imageserver.Params) (*url.URL, error) {
source, err := params.GetString(imageserver.SourceParam)
if err != nil {
return nil, err
}
sourceURL, err := url.ParseRequestURI(source)
if err != nil {
return nil, &imageserver.ParamError{
Param: imageserver.SourceParam,
Message: fmt.Sprintf("parse url error: %s", err),
}
}
if sourceURL.Scheme != "http" && sourceURL.Scheme != "https" {
return nil, &imageserver.ParamError{
Param: imageserver.SourceParam,
Message: "url scheme must be http(s)",
}
}
return sourceURL, nil
}
func TestSourcePrefixParser(t *testing.T) {
req, err := http.NewRequest("GET", "http://localhost?source=bar", nil)
if err != nil {
t.Fatal(err)
}
ps := &SourcePrefixParser{
Parser: &SourceParser{},
Prefix: "foo",
}
params := imageserver.Params{}
err = ps.Parse(req, params)
if err != nil {
t.Fatal(err)
}
source, err := params.GetString(imageserver_source.Param)
if err != nil {
t.Fatal(err)
}
if source != "foobar" {
t.Fatal("not equals")
}
}
func (hdr *Handler) buildArgumentsBackground(arguments *list.List, params imageserver.Params) error {
if !params.Has("background") {
return nil
}
background, err := params.GetString("background")
if err != nil {
return err
}
switch len(background) {
case 3, 4, 6, 8:
default:
return &imageserver.ParamError{Param: "background", Message: "length must be equal to 3, 4, 6 or 8"}
}
for _, r := range background {
if (r < '0' || r > '9') && (r < 'a' || r > 'f') {
return &imageserver.ParamError{Param: "background", Message: "must only contain characters in 0-9a-f"}
}
}
arguments.PushBack("-background")
arguments.PushBack(fmt.Sprintf("#%s", background))
return nil
}
func TestSourceTransformParser(t *testing.T) {
req, err := http.NewRequest("GET", "http://localhost?source=foo", nil)
if err != nil {
t.Fatal(err)
}
ps := &SourceTransformParser{
Parser: &SourceParser{},
Transform: func(source string) string {
return "bar"
},
}
params := imageserver.Params{}
err = ps.Parse(req, params)
if err != nil {
t.Fatal(err)
}
source, err := params.GetString(imageserver.SourceParam)
if err != nil {
t.Fatal(err)
}
if source != "bar" {
t.Fatal("not equals")
}
}
func (hdr *Handler) buildArgumentsFormat(arguments *list.List, params imageserver.Params, sourceImage *imageserver.Image) (format string, formatSpecified bool, err error) {
if !params.Has("format") {
return sourceImage.Format, false, nil
}
format, err = params.GetString("format")
if err != nil {
return "", false, err
}
if hdr.AllowedFormats != nil {
ok := false
for _, f := range hdr.AllowedFormats {
if f == format {
ok = true
break
}
}
if !ok {
return "", false, &imageserver.ParamError{Param: "format", Message: "not allowed"}
}
}
arguments.PushBack("-format")
arguments.PushBack(format)
return format, true, nil
}
