func RequireValidImageParameters(w traffic.ResponseWriter, r *traffic.Request) {
width, err := strconv.Atoi(r.Param("width"))
if err != nil {
w.WriteHeader(http.StatusNotFound)
return
}
height, err := strconv.Atoi(r.Param("height"))
if err != nil {
height = width
}
if (width <= 2560 && width > 0) && (height <= 2560 && height > 0) {
w.SetVar("width", width)
w.SetVar("height", height)
// log latest greatest creation
if err := ioutil.WriteFile(filepath.Join(cache_folder, "/latest"), []byte(fmt.Sprintf("%d/%d", width, height)), 0644); err != nil {
// panic is trapped by Traffic and show us a nice stack trace in the browser
// a proper error handling should be provided, but in this simple example
// it's used to remind you to always check for errors
panic(err)
}
} else {
// bad request
w.WriteHeader(http.StatusBadRequest)
w.Render("400")
}
}
func GenerateImageCache(w traffic.ResponseWriter, r *traffic.Request) {
if !exists(cache_folder) {
if err := os.Mkdir(cache_folder, 0644); err != nil {
panic(err)
}
}
filename := fmt.Sprintf("%s/%dx%d.jpg", cache_folder, w.GetVar("width"), w.GetVar("height"))
w.SetVar("filename", filename)
if !exists(filename) {
// file does not exists, generate a cached version
width := w.GetVar("width").(int)
height := w.GetVar("height").(int)
src_image := loadImageFromFile(image_file)
pattern := resizeImage(src_image, width, height)
var dst_image image.Image
if width > height {
dst_image = tileImageHorizontally(pattern, width, height)
} else {
dst_image = tileImageVertically(pattern, width, height)
}
saveImageToFile(filename, dst_image)
}
}
func CheckReleaseFilter(w traffic.ResponseWriter, r *traffic.Request) {
artistId := r.URL.Query().Get("artist_id")
releaseId := r.URL.Query().Get("release_id")
if releaseId == "" {
return
}
if !models.IsValidUUID(releaseId) {
w.WriteHeader(http.StatusBadRequest)
return
}
if artistId != "" {
if !models.IsValidUUID(artistId) {
w.WriteHeader(http.StatusBadRequest)
return
}
if artist.HasRelease(artistId, releaseId) {
return
}
ReleaseNotFoundHandler(w, r)
return
}
if !release.Exists(releaseId) {
ReleaseNotFoundHandler(w, r)
return
}
}
func rootHandler(w traffic.ResponseWriter, r *traffic.Request) {
response := map[string]string{
"version": VERSION,
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(response)
}
func RootHandler(w traffic.ResponseWriter, r *traffic.Request) {
last_image_generated, err := ioutil.ReadFile("cache/latest")
if err != nil {
responseData := &ResponseData{string(last_image_generated)}
w.Render("index", responseData)
}
}
func pageHandler(w traffic.ResponseWriter, r *traffic.Request) {
pagePath := r.Param("page_path")
responseData := &ResponseData{
PagePath: pagePath,
}
w.Render("index", responseData)
}
func CheckForDdosString(w traffic.ResponseWriter, r *traffic.Request) {
for k, _ := range uriFragments {
fmt.Printf("Searching for %s in %s", k, r.RequestURI)
if strings.Contains(r.RequestURI, k) {
fmt.Printf("Found %s", k)
w.WriteHeader(http.StatusGatewayTimeout)
w.WriteText("connection timed out")
}
}
}
func rootHandler(w traffic.ResponseWriter, r *traffic.Request) {
logger := w.GetVar("chromelogger").(*chromelogger.Logger)
logger.Log("Hello")
logger.Log(map[string]string{
"foo": "bar",
})
w.WriteText("Hello, check your Chrome console after activating the Chrome Logger extension.\n")
}
func xmlTestHandler(w traffic.ResponseWriter, r *traffic.Request) {
type Person struct {
FirstName string `xml:"name>first"`
LastName string `xml:"name>last"`
}
w.WriteXML(&Person{
FirstName: "foo",
LastName: "bar",
})
}
func codesHandler(w traffic.ResponseWriter, r *traffic.Request) {
code := r.Param("code")
url := fmt.Sprintf("%s%s", baseUrl, code)
grid, err := qrencode.Encode(url, qrencode.ECLevelQ)
if err != nil {
panic(err)
}
w.Header().Set("Content-Type", "image/png")
png.Encode(w, grid.Image(8))
}
func (api *ImgServerApi) deleteHandler(w traffic.ResponseWriter, r *traffic.Request) {
filename := r.URL.Query().Get("image")
err := api.imageDir.DeleteFile(filename)
api.imageCache.Remove(api.imageCache.FindKeys(filename))
if err != nil {
traffic.Logger().Print(err.Error())
w.WriteHeader(http.StatusNotFound)
} else {
w.WriteHeader(http.StatusOK)
}
}
// If the request path is "/ping", it writes PONG in the response and returns without calling the next middleware
// Otherwise it sets the variable "PING" with PONG as value and calls the next middleware.
// The next middleware and the final handler can get that variable with:
// w.GetVar("ping")
func (c *PingMiddleware) ServeHTTP(w traffic.ResponseWriter, r *traffic.Request, next traffic.NextMiddlewareFunc) {
if r.URL.Path == "/ping" {
w.WriteText("pong\n")
return
}
if nextMiddleware := next(); nextMiddleware != nil {
w.SetVar("ping", "pong")
nextMiddleware.ServeHTTP(w, r, next)
}
return
}
func rootHandler(w traffic.ResponseWriter, r *traffic.Request) {
w.WriteText("%s<br />", w.GetVar("foo"))
// run with TRAFFIC_ENV=production to get the "bar" value
// from the production section of the config file
w.WriteText("%s<br />", w.GetVar("bar"))
}
func ArtistHandler(w traffic.ResponseWriter, r *traffic.Request) {
id := r.URL.Query().Get("id")
Artist, err := artist.ById(id)
if err == nil {
json.NewEncoder(w).Encode(Artist)
} else if err == sql.ErrNoRows {
ArtistNotFoundHandler(w, r)
} else if _, ok := err.(models.InvalidUUID); ok {
w.WriteHeader(http.StatusBadRequest)
} else {
panic(err)
}
}
func ReleaseGroupsHandler(w traffic.ResponseWriter, r *traffic.Request) {
artistId := r.URL.Query().Get("artist_id")
ReleaseGroups, err := releasegroup.AllByArtistId(artistId)
if err == nil {
json.NewEncoder(w).Encode(ReleaseGroups)
} else if err == sql.ErrNoRows {
w.WriteHeader(http.StatusNotFound)
} else if _, ok := err.(models.InvalidUUID); ok {
w.WriteHeader(http.StatusBadRequest)
} else {
panic(err)
}
}
func (api *ImgServerApi) listHandler(w traffic.ResponseWriter, r *traffic.Request) {
age, err := strconv.Atoi(r.Param("age"))
if err != nil {
age = 0
}
files, err := api.imageDir.ListFiles(time.Duration(age) * time.Second)
if err != nil {
traffic.Logger().Print(err.Error())
w.WriteHeader(http.StatusInternalServerError)
} else {
w.WriteJSON(files)
}
}
func CheckArtistFilter(w traffic.ResponseWriter, r *traffic.Request) {
artistId := r.URL.Query().Get("artist_id")
if artistId == "" {
return
}
if !models.IsValidUUID(artistId) {
w.WriteHeader(http.StatusBadRequest)
return
}
if !artist.Exists(artistId) {
ArtistNotFoundHandler(w, r)
return
}
}
func (c *Middleware) ServeHTTP(w traffic.ResponseWriter, r *traffic.Request, next traffic.NextMiddlewareFunc) {
ok := miniprofiler.Enable(r.Request)
if ok && strings.HasPrefix(r.Request.URL.Path, miniprofiler.PATH) {
miniprofiler.MiniProfilerHandler(w, r.Request)
return
}
p := miniprofiler.NewProfile(w, r.Request, r.URL.Path)
w.SetVar("miniprofiler", p.Includes())
w.SetVar("miniprofiler_timer", p)
if nextMiddleware := next(); nextMiddleware != nil {
nextMiddleware.ServeHTTP(w, r, next)
}
if ok {
p.Finalize()
}
return
}
func RecordingsHandler(w traffic.ResponseWriter, r *traffic.Request) {
releaseId := r.URL.Query().Get("release_id")
var recordings []*models.Recording
var err error
recordings, err = recording.AllByReleaseId(releaseId)
if err == nil {
json.NewEncoder(w).Encode(recordings)
} else if err == sql.ErrNoRows {
w.WriteHeader(http.StatusNotFound)
} else if _, ok := err.(models.InvalidUUID); ok {
w.WriteHeader(http.StatusBadRequest)
} else {
panic(err)
}
}
func RecordingHandler(w traffic.ResponseWriter, r *traffic.Request) {
releaseId := r.URL.Query().Get("release_id")
id := r.URL.Query().Get("id")
var Recording *models.Recording
var err error
if releaseId != "" {
Recording, err = recording.ByReleaseIdAndId(releaseId, id)
} else {
Recording, err = recording.ById(id)
}
if err == nil {
json.NewEncoder(w).Encode(Recording)
} else if err == sql.ErrNoRows {
RecordingNotFoundHandler(w, r)
} else if _, ok := err.(models.InvalidUUID); ok {
w.WriteHeader(http.StatusBadRequest)
} else {
panic(err)
}
}
func ReleasesHandler(w traffic.ResponseWriter, r *traffic.Request) {
artistId := r.URL.Query().Get("artist_id")
releaseGroupId := r.URL.Query().Get("release_group_id")
var releases []*models.Release
var err error
if releaseGroupId == "" {
releases, err = release.AllByArtistId(artistId)
} else {
releases, err = release.AllByReleaseGroupId(releaseGroupId)
}
if err == nil {
json.NewEncoder(w).Encode(releases)
} else if err == sql.ErrNoRows {
ReleaseNotFoundHandler(w, r)
} else if _, ok := err.(models.InvalidUUID); ok {
w.WriteHeader(http.StatusBadRequest)
} else {
panic(err)
}
}
func ReleaseGroupHandler(w traffic.ResponseWriter, r *traffic.Request) {
artistId := r.URL.Query().Get("artist_id")
id := r.URL.Query().Get("id")
var ReleaseGroup *models.ReleaseGroup
var err error
if artistId != "" {
ReleaseGroup, err = releasegroup.ByArtistIdAndId(artistId, id)
} else {
ReleaseGroup, err = releasegroup.ById(id)
}
if err == nil {
json.NewEncoder(w).Encode(ReleaseGroup)
} else if err == sql.ErrNoRows {
ReleaseGroupNotFoundHandler(w, r)
} else if _, ok := err.(models.InvalidUUID); ok {
w.WriteHeader(http.StatusBadRequest)
} else {
panic(err)
}
}
func ImageHandler(w traffic.ResponseWriter, r *traffic.Request) {
// output the image with the correct content-type
w.Header().Set("Content-Type", "image/jpeg")
// at this point we can safely assume that the image file already exists
if image_data, err := ioutil.ReadFile(w.GetVar("filename").(string)); err != nil {
panic(err)
} else {
w.Write(image_data)
}
}
func (api *ImgServerApi) uploadHandler(w traffic.ResponseWriter, r *traffic.Request) {
filename := r.URL.Query().Get("image")
uploadedImage, _, err := image.Decode(r.Body)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
} else {
img := drawOnWhite(uploadedImage.Bounds().Size(), image.Pt(0, 0), image.Pt(0, 0), uploadedImage)
err = api.imageDir.WriteImage(filename, img, 100)
if err != nil {
traffic.Logger().Print(err.Error())
w.WriteHeader(http.StatusInternalServerError)
} else {
w.WriteHeader(http.StatusOK)
}
}
}
func (api *ImgServerApi) copyHandler(w traffic.ResponseWriter, r *traffic.Request) {
src := r.URL.Query().Get("src")
dst := r.URL.Query().Get("dst")
data, err := api.imageDir.ReadFile(src)
if err != nil {
w.WriteHeader(http.StatusNotFound)
return
}
err = api.imageDir.WriteFile(dst, data)
if err != nil {
traffic.Logger().Print(err.Error())
w.WriteHeader(http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
}
func (api *ImgServerApi) imageHandler(w traffic.ResponseWriter, r *traffic.Request) {
params := r.URL.Query()
width := toInt(params.Get("width"), 0)
height := toInt(params.Get("height"), 0)
imagefile := params.Get("image")
cacheKey := imagefile + string(width) + string(height)
modTime := api.imageDir.ModTime(imagefile)
if modTime == nil {
api.imageCache.Remove(api.imageCache.FindKeys(imagefile))
w.WriteHeader(http.StatusNotFound)
return
}
if cachedImage := api.imageCache.Get(cacheKey, *modTime); cachedImage != nil {
sendJpeg(w, cachedImage)
} else {
origImage, err := api.imageDir.ReadImage(imagefile)
if err != nil {
traffic.Logger().Print(err.Error())
w.WriteHeader(http.StatusNotFound)
} else {
semaphore <- struct{}{}
buffer := new(bytes.Buffer)
sizedImage := resizeImage(origImage, width, height, api.faceDetection)
err = jpeg.Encode(buffer, sizedImage, &jpeg.Options{95})
<-semaphore
if err != nil {
traffic.Logger().Print(err.Error())
w.WriteHeader(http.StatusInternalServerError)
} else {
data := make([]byte, buffer.Len())
buffer.Read(data)
api.imageCache.Put(cacheKey, data, *modTime)
sendJpeg(w, data)
}
}
}
}
func rootHandler(w traffic.ResponseWriter, r *traffic.Request) {
traffic.Logger().Print("Hello")
w.WriteText("Hello World\n")
}
func pageHandler(w traffic.ResponseWriter, r *traffic.Request) {
w.WriteText("Category ID: %s\n", r.Param("category_id"))
w.WriteText("Page ID: %s\n", r.Param("id"))
}
func jsonTestHandler(w traffic.ResponseWriter, r *traffic.Request) {
data := map[string]string{
"foo": "bar",
}
w.WriteJSON(data)
}
// traffic
func trafficHandler(w traffic.ResponseWriter, r *traffic.Request) {
if sleepTime > 0 {
time.Sleep(sleepTimeDuration)
}
w.Write(message)
}