Example #1
0
File: map.go Project: GeoNet/mtr
/*
MapRaw returns a Raw struct which can be used for drawing SVG maps e.g.,

    raw, err := wm.MapRaw(bbox, width)
    b := bytes.Buffer
    b.WriteString(`<?xml version="1.0"?>`)
    b.WriteString(fmt.Sprintf("<svg  viewBox=\"0 0 %d %d\"  xmlns=\"http://www.w3.org/2000/svg\">",
    raw.Width, raw.Height))
    b.WriteString(fmt.Sprintf("<rect x=\"0\" y=\"0\" width=\"%d\" height=\"%d\" style=\"fill: azure\"/>", raw.Width, raw.Height))
    b.WriteString(fmt.Sprintf("<path style=\"fill: wheat; stroke-width: 1; stroke-linejoin: round; stroke: lightslategrey\" d=\"%s\"/>", raw.Land))
    b.WriteString(fmt.Sprintf("<path style=\"fill: azure; stroke-width: 1; stroke-linejoin: round; stroke: lightslategrey\" d=\"%s\"/>", raw.Lakes))
    b.WriteString("</svg>")

The other properties can be used to scale and translate for drawing on the map e.g.,

    type point struct {
	latitude, longitude float64
	x, y                float64
    }

    // create pts []point with x,y, set to EPSG3857 and latitude longitude EPSG4326
    // range of pts ...

    switch raw.CrossesCentral && p.longitude > -180.0 && p.longitude < 0.0 {
	case true:
		p.x = (p.x + map180.Width3857 - raw.LLX) * raw.DX
		p.y = (p.y - math.Abs(raw.YShift)) * raw.DX
	case false:
		p.x = (p.x - math.Abs(raw.XShift)) * raw.DX
		p.y = (p.y - math.Abs(raw.YShift)) * raw.DX
    }

    // draw p on SVG.


*/
func (w *Map180) MapRaw(boundingBox string, width int) (mr Raw, err error) {
	var b bbox
	if b, err = newBbox(boundingBox); err != nil {
		return
	}

	var m map3857
	if m, err = b.newMap3857(width); err != nil {
		return
	}

	mr.Height = m.height
	mr.Width = m.width
	mr.DX = m.dx
	mr.CrossesCentral = m.crossesCentral
	mr.LLX = m.llx
	mr.YShift = m.yshift
	mr.XShift = m.xshift

	// Get the land and lakes layers from the cache.  This creates them
	// if they haven't been cached already.
	if err = landLayers.Get(nil, m.toKey(), groupcache.StringSink(&mr.Land)); err != nil {
		return
	}

	if err = lakeLayers.Get(nil, m.toKey(), groupcache.StringSink(&mr.Lakes)); err != nil {
		return
	}

	return
}
Example #2
0
File: gp.go Project: Wuvist/gws
func proxyHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("content-type", "application/json")
	url := "http://moapi.com:8080" + r.URL.Path + "?" + r.URL.RawQuery

	var s string
	stringcache.Get(nil, url, groupcache.StringSink(&s))
	fmt.Fprintf(w, s)
}
Example #3
0
func (c *groupCacheMgr) GetValue(request *api.ValueRequest) {
	log.WithField("domain", request.Key).Info("GroupCache:GetValue")

	var value string
	err := c.group.Get(request, request.Key, gc.StringSink(&value))

	log.WithFields(log.Fields{
		"domain": request.Key,
		"value":  value,
	}).Info("GroupCache:GetValue:Get")

	// send response to client
	request.Response <- api.NewValueResponse(value, err)
	close(request.Response)

	log.WithField("domain", request.Key).Info("GroupCache:GetValue:Done")
}
Example #4
0
func main() {

	// setup group
	stringGroup = gc.NewGroup(stringGroupName, cacheSize, gc.GetterFunc(func(_ gc.Context, key string, dest gc.Sink) error {
		fmt.Fprintf(os.Stdout, "Setting cache key: %s\n", key)
		return dest.SetString("ECHO:" + key)
	}))

	// Get Items
	for j := 0; j < 4; j++ {
		for i := 0; i < 4; i++ {
			var s string
			if err := stringGroup.Get(dummyCtx, "TestCaching-key"+strconv.Itoa(i), gc.StringSink(&s)); err != nil {
				fmt.Fprintf(os.Stdout, "TestCaching-key value: failed%s\n", err)
				return
			}
			fmt.Fprintf(os.Stdout, "TestCaching-key value:%s\n", s)
		}
		fmt.Fprintln(os.Stdout, "---")
	}

	fmt.Fprintln(os.Stdout, "Done.")
}
Example #5
0
File: main.go Project: qmdx/mygo
func QR(w http.ResponseWriter, req *http.Request) {
	locals := make(map[string]string)
	locals["s"] = req.FormValue("s")
	if len(locals["s"]) > 0 {
		var value string
		if err := cg.Get(nil, locals["s"], gc.StringSink(&value)); err != nil {
			fmt.Printf("err: %v\n", err)
		}
		locals["image"] = value
	}
	templ.Execute(w, locals)
	// show groupcache stats
	fmt.Printf("####### Stats ######")
	fmt.Printf("Group Stats:\n")
	fmt.Printf("   Gets: %d\n", cg.Stats.Gets)
	fmt.Printf("   CacheHits: %d\n", cg.Stats.CacheHits)
	fmt.Printf("   PeerLoads: %d\n", cg.Stats.PeerLoads)
	fmt.Printf("   PeerErrors: %d\n", cg.Stats.PeerErrors)
	fmt.Printf("   Loads: %d\n", cg.Stats.Loads)
	fmt.Printf("   LoadsDeduped: %d\n", cg.Stats.LoadsDeduped)
	fmt.Printf("   LocalLoads: %d\n", cg.Stats.LocalLoads)
	fmt.Printf("   LocalLoadErrs: %d\n", cg.Stats.LocalLoadErrs)
	fmt.Printf("   ServerRequests: %d\n", cg.Stats.ServerRequests)
}
Example #6
0
File: map.go Project: GeoNet/mtr
/*
Map draws an SVG image to buf for the bbox regions.  The returned map uses EPSG3857.
Width is the SVG image width in pixels (height is calculated). pts haz X Y and values
initialised for later drawing.  The SVG in buf is not closed.  See ValidBbox for boundingBox options.
*/
func (w *Map180) Map(boundingBox string, width int, pts Points, insetBbox string, buf *bytes.Buffer) (err error) {
	// If the bbox is zero type then figure it out from the markers.
	var b bbox
	b, err = newBbox(boundingBox)
	if err != nil {
		return
	}

	m, err := b.newMap3857(width)
	if err != nil {
		return
	}

	buf.WriteString(`<?xml version="1.0"?>`)
	buf.WriteString(fmt.Sprintf("<svg  viewBox=\"0 0 %d %d\"  xmlns=\"http://www.w3.org/2000/svg\">",
		m.width, m.height))
	if b.title != "" {
		buf.WriteString(`<title>Map of ` + b.title + `.</title>`)
	} else {
		buf.WriteString(`<title>Map of ` + boundingBox + `.</title>`)
	}

	// Get the land and lakes layers from the cache.  This creates them
	// if they haven't been cached already.
	var landLakes string

	err = mapLayers.Get(nil, m.toKey(), groupcache.StringSink(&landLakes))
	if err != nil {
		return
	}

	buf.WriteString(landLakes)

	if insetBbox != "" {
		var inset bbox
		inset, err = newBbox(insetBbox)
		if err != nil {
			return
		}
		var in map3857
		in, err = inset.newMap3857(80)
		if err != nil {
			return
		}

		var insetMap string
		err = mapLayers.Get(nil, in.toKey(), groupcache.StringSink(&insetMap))
		if err != nil {
			return
		}

		// use 2 markers to put a the main map bbox as a rect
		ibboxul := NewMarker(b.llx, b.ury, ``, ``, ``)
		err = in.marker3857(&ibboxul)
		if err != nil {
			return
		}

		ibboxlr := NewMarker(b.urx, b.lly, ``, ``, ``)
		err = in.marker3857(&ibboxlr)
		if err != nil {
			return
		}

		// if bbox rect is tiny make it bigger and shift it a little.
		iw := int(ibboxlr.x - ibboxul.x)
		if iw < 5 {
			iw = 5
			ibboxul.x = ibboxul.x - 2
		}

		ih := int(ibboxlr.y - ibboxul.y)
		if ih < 5 {
			ih = 5
			ibboxul.y = ibboxul.y - 2
		}

		buf.WriteString(fmt.Sprintf("<g transform=\"translate(10,10)\"><rect x=\"-3\" y=\"-3\" width=\"%d\" height=\"%d\" rx=\"10\" ry=\"10\" fill=\"white\"/>",
			in.width+6, in.height+6))

		buf.WriteString(insetMap)

		buf.WriteString(fmt.Sprintf("<rect x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" fill=\"red\" opacity=\"0.5\"/>",
			int(ibboxul.x), int(ibboxul.y), iw, ih) + `</g>`)

	} // end of inset

	for i, _ := range pts {
		if pts[i].Latitude <= 85.0 && pts[i].Latitude >= -85.0 {
			if err = m.point3857(&pts[i]); err != nil {
				return
			}
		}
	}

	return
}
Example #7
0
File: map.go Project: GeoNet/mtr
/*
SVG draws an SVG image showing a map of markers.  The returned map uses EPSG3857.
Width is the SVG image width in pixels (height is calculated).
If boundingBox is the empty string then the map bounds are calculated from the markers.
See ValidBbox for boundingBox options.
*/
func (w *Map180) SVG(boundingBox string, width int, markers []Marker, insetBbox string) (buf bytes.Buffer, err error) {
	// If the bbox is zero type then figure it out from the markers.
	var b bbox
	if boundingBox == "" {
		b, err = newBboxFromMarkers(markers)
		if err != nil {
			return
		}
	} else {
		b, err = newBbox(boundingBox)
		if err != nil {
			return
		}
	}

	m, err := b.newMap3857(width)
	if err != nil {
		return
	}

	buf.WriteString(`<?xml version="1.0"?>`)
	buf.WriteString(fmt.Sprintf("<svg height=\"%d\" width=\"%d\" xmlns=\"http://www.w3.org/2000/svg\">",
		m.height, m.width))
	if b.title != "" {
		buf.WriteString(`<title>Map of ` + b.title + `.</title>`)
	} else {
		buf.WriteString(`<title>Map of ` + boundingBox + `.</title>`)
	}

	// Get the land and lakes layers from the cache.  This creates them
	// if they haven't been cached already.
	var landLakes string

	err = mapLayers.Get(nil, m.toKey(), groupcache.StringSink(&landLakes))
	if err != nil {
		return
	}

	buf.WriteString(landLakes)

	if insetBbox != "" {
		var inset bbox
		inset, err = newBbox(insetBbox)
		if err != nil {
			return
		}
		var in map3857
		in, err = inset.newMap3857(80)
		if err != nil {
			return
		}

		var insetMap string
		err = mapLayers.Get(nil, in.toKey(), groupcache.StringSink(&insetMap))
		if err != nil {
			return
		}

		// use 2 markers to put a the main map bbox as a rect
		ibboxul := NewMarker(b.llx, b.ury, ``, ``, ``)
		err = in.marker3857(&ibboxul)
		if err != nil {
			return
		}

		ibboxlr := NewMarker(b.urx, b.lly, ``, ``, ``)
		err = in.marker3857(&ibboxlr)
		if err != nil {
			return
		}

		// if bbox rect is tiny make it bigger and shift it a little.
		iw := int(ibboxlr.x - ibboxul.x)
		if iw < 5 {
			iw = 5
			ibboxul.x = ibboxul.x - 2
		}

		ih := int(ibboxlr.y - ibboxul.y)
		if ih < 5 {
			ih = 5
			ibboxul.y = ibboxul.y - 2
		}

		buf.WriteString(fmt.Sprintf("<g transform=\"translate(10,10)\"><rect x=\"-3\" y=\"-3\" width=\"%d\" height=\"%d\" rx=\"10\" ry=\"10\" fill=\"white\"/>",
			in.width+6, in.height+6))

		buf.WriteString(insetMap)

		buf.WriteString(fmt.Sprintf("<rect x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" fill=\"red\" opacity=\"0.5\"/>",
			int(ibboxul.x), int(ibboxul.y), iw, ih) + `</g>`)

	} // end of inset

	err = m.drawMarkers(markers, &buf)
	if err != nil {
		return
	}

	var short bool
	if m.width < 250 {
		short = true
	}
	labelMarkers(markers, m.width-5, m.height-5, `end`, 12, short, &buf)

	buf.WriteString("</svg>")
	return
}
// Get is used by GroupCache to load a key not found in the cache
func (pc *PodAuthCache) Get(podname string) string {
	var auth string
	pc.cacheGroup.Get(nil, podname, groupcache.StringSink(&auth))
	return auth
}
Example #9
0
func TestGRPCPool(t *testing.T) {
	if *peerChild {
		beChildForTestGRPCPool()
		os.Exit(0)
	}

	const (
		nChild = 5
		nGets  = 5000
	)

	var childAddr []string
	for i := 0; i < nChild; i++ {
		childAddr = append(childAddr, pickFreeAddr(t))
	}

	var cmds []*exec.Cmd
	var wg sync.WaitGroup
	for i := 0; i < nChild; i++ {
		cmd := exec.Command(os.Args[0],
			"--test.run=TestGRPCPool",
			"--test_peer_child",
			"--test_peer_addrs="+strings.Join(childAddr, ","),
			"--test_peer_index="+strconv.Itoa(i),
		)
		cmds = append(cmds, cmd)
		wg.Add(1)
		if err := cmd.Start(); err != nil {
			t.Fatal("failed to start child process: ", err)
		}
		go awaitAddrReady(t, childAddr[i], &wg)
	}
	defer func() {
		for i := 0; i < nChild; i++ {
			if cmds[i].Process != nil {
				cmds[i].Process.Kill()
			}
		}
	}()
	wg.Wait()

	// Use a dummy self address so that we don't handle gets in-process.
	p := NewGRPCPool("should-be-ignored", grpc.NewServer())
	p.Set(childAddr...)

	// Dummy getter function. Gets should go to children only.
	// The only time this process will handle a get is when the
	// children can't be contacted for some reason.
	getter := groupcache.GetterFunc(func(ctx groupcache.Context, key string, dest groupcache.Sink) error {
		return errors.New("parent getter called; something's wrong")
	})
	g := groupcache.NewGroup("grpcPoolTest", 1<<20, getter)

	for _, key := range testKeys(nGets) {
		var value string
		if err := g.Get(nil, key, groupcache.StringSink(&value)); err != nil {
			t.Fatal(err)
		}
		if suffix := ":" + key; !strings.HasSuffix(value, suffix) {
			t.Errorf("Get(%q) = %q, want value ending in %q", key, value, suffix)
		}
		t.Logf("Get key=%q, value=%q (peer:key)", key, value)
	}
}
Example #10
0
func main() {
	// Parse the flags
	flag.Parse()

	// Create a new groupcache pool
	pool := groupcache.NewHTTPPool(*cachePublic)
	pool.Set(strings.Split(*cachePeers, ",")...)

	// Listen and serve the groupcache pool
	cacheServer := http.Server{
		Addr:    *cacheBind,
		Handler: pool,
	}
	go func() {
		log.Printf("Starting up the cache HTTP server on address %s", *cacheBind)

		err := cacheServer.ListenAndServe()
		if err != nil {
			log.Fatal(err)
		}
	}()

	// Create a new groupcache pool
	cache := groupcache.NewGroup("ritratt", *cacheSize, groupcache.GetterFunc(func(ctx groupcache.Context, url string, dest groupcache.Sink) error {
		// First try with https
		schema := "https://"
		resp, err := http.Head("https://" + url)
		if err != nil {
			log.Printf("[https] Error while querying %s: %s", url, err)

			// https doesn't work, try http
			schema = "http://"
			resp, err = http.Head("http://" + url)
			if err != nil {
				log.Printf("[http] Error while querying %s: %s", url, err)
			}
		}

		// Content-Type of the result has to start with image/
		// We also don't support SVGs, check out this link for more information:
		// https://www.owasp.org/images/0/03/Mario_Heiderich_OWASP_Sweden_The_image_that_called_me.pdf
		/*ct := resp.Header.Get("Content-Type")
		if !strings.HasPrefix(ct, "image/") || strings.Contains(ct, "image/svg+xml") {
			log.Printf("[head] Invalid Content-Type of %s", url)
			return ErrInvalidContentType
		}*/

		// Query the proper URL, now including the body
		resp, err = http.Get(schema + url)
		defer resp.Body.Close()
		if err != nil {
			log.Printf("[get] Error while querying %s: %s", url, err)
		} else {
			log.Printf("[get] Loaded %s", url)
		}

		// Content-Type check #2
		ct := resp.Header.Get("Content-Type")
		if !strings.HasPrefix(ct, "image/") || strings.Contains(ct, "image/svg+xml") {
			log.Printf("[get] Invalid Content-Type of %s", url)
			return ErrInvalidContentType
		}

		var body []byte

		// Read the dlenght
		cls := resp.Header.Get("Content-Length")
		if cls != "" {
			cl, err := strconv.Atoi(cls)
			if err != nil {
				log.Print(err)
			} else {
				if cl > 25*1024*1024 {
					return ErrTooBig
				} else {
					body, err = ioutil.ReadAll(resp.Body)
					if err != nil {
						return err
					}
				}
			}
		} else {
			body = []byte{}
			totalRead := 0

			for {
				chunk := make([]byte, 1024*1024)

				read, err := resp.Body.Read(chunk)
				totalRead += read

				if err == io.EOF {
					break
				}

				if err != nil {
					return err
				}

				body = append(body, chunk[:read]...)

				if totalRead > 25*1024*1024 {
					return ErrTooBig
				}
			}
		}

		// Put the body into cache with the Content-Type
		dest.SetString(ct + ";" + string(body))

		return nil
	}))

	log.Printf("Starting up the proxy HTTP server on address %s", *proxyBind)
	proxyServer := http.Server{
		Addr: *proxyBind,
		Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			// Index page
			if len(r.RequestURI) < 3 || r.RequestURI[:3] != "/i/" {
				w.Write([]byte("lavab/ritratt"))
				return
			}

			// Get the data from groupcache
			var data string
			err := cache.Get(nil, r.RequestURI[3:], groupcache.StringSink(&data))
			if err != nil {
				w.Write([]byte(err.Error()))
				return
			}

			// Split the result into two parts
			parts := strings.SplitN(data, ";", 2)

			// Set the content type
			w.Header().Set("Content-Type", parts[0])

			// Write the body
			w.Write([]byte(parts[1]))
		}),
	}
	log.Fatal(proxyServer.ListenAndServe())
}