Example #1
0
func DownloadDtD(c *gin.Context) {
	c.Header("Content-Type", "text/xml; charset=\"utf-8\"")
	url := c.Request.URL.RequestURI()[1:]
	timeout := time.Duration(5 * time.Second)
	client := http.Client{
		Timeout: timeout,
	}
	resp, err := client.Get(fmt.Sprintf("http://%s", url))
	if resp.StatusCode != 200 {
		c.String(http.StatusServiceUnavailable, "fail to reach baclend")
		return
	}
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		c.String(http.StatusInternalServerError, "fail to read body")
	}
	defer resp.Body.Close()
	if len(body) == 0 {
		c.String(http.StatusServiceUnavailable, "fail to read body")
		return
	}
	c.Header("Cache-Control", "max-age=436800")
	c.String(http.StatusOK, string(body))
	filePath := fmt.Sprintf("%s%s", *cachePath, c.Request.URL.Path)
	paths := strings.Split(filePath, "/")
	err = os.MkdirAll(strings.Join(paths[:len(paths)-1], "/"), os.ModeDir|os.ModePerm)
	err = ioutil.WriteFile(filePath, body, 0644)
	if err != nil {
		return
	}
}
// PreAbort will set the appropriate HTTP Basic header.
func (m HTTPBasicAuth) PreAbort(c *gin.Context, auth *AuthInfo, err *AuthErr) {
	if m.Realm == "" {
		m.Realm = "Authorization Required"
	}
	m.Realm = "Basic realm=" + strconv.Quote(m.Realm)
	c.Header("WWW-Authenticate", m.Realm)
}
Example #3
0
func view(c *gin.Context) {
	id := c.Param("uniuri")
	key := c.Param("key")
	re := models.ResourceEntry{}
	remote := c.ClientIP()

	db.Where(&models.ResourceEntry{Key: id}).First(&re)
	if re.Key == "" {
		log.Printf("[INFO][%s]\tNot found : %s", remote, id)
		c.AbortWithStatus(http.StatusNotFound)
		return
	}
	log.Printf("[INFO][%s]\tFetched %s file and entry\n", remote, id)
	f, err := os.Open(path.Join(conf.C.UploadDir, re.Key))
	if err != nil {
		log.Printf("[ERROR][%s]\tWhile opening %s file\n", remote, id)
		c.AbortWithStatus(http.StatusInternalServerError)
		return
	}
	block, err := aes.NewCipher([]byte(key))
	if err != nil {
		log.Printf("[ERROR][%s]\tDuring Cipher creation : %s\n", remote, err)
		c.String(http.StatusInternalServerError, "Something went wrong on the server side. Try again later.")
		c.AbortWithStatus(http.StatusInternalServerError)
		return
	}
	var iv [aes.BlockSize]byte
	stream := cipher.NewCFBDecrypter(block, iv[:])
	reader := &cipher.StreamReader{S: stream, R: f}
	c.Header("Content-Disposition", "filename=\""+re.Name+"\"")
	io.Copy(c.Writer, reader)
}
Example #4
0
func badgeImageScwBuildEndpoint(c *gin.Context) {
	name := c.Param("name")
	images := cache.GetImageByName(name)
	left := "build"
	c.Header("Content-Type", "image/svg+xml;charset=utf-8")
	switch len(images) {
	case 0:
		c.String(http.StatusNotFound, devhub.ErrBadge(left, fmt.Errorf("no such image")))
	case 1:
		image := images[0]
		if image.Objects.Api == nil {
			c.String(http.StatusInternalServerError, devhub.ErrBadge(left, fmt.Errorf("invalid resource")))
			return
		}
		creationDate, err := time.Parse(time.RFC3339, image.Objects.Api.CreationDate)
		if err != nil {
			c.String(http.StatusInternalServerError, devhub.ErrBadge(left, fmt.Errorf("invalid-date")))
			return
		}

		humanTime := humanize.Time(creationDate)
		humanTime = strings.Replace(humanTime, " ago", "", -1)

		badge, err := devhub.GetBadge(left, humanTime, "green")
		if err != nil {
			c.String(http.StatusInternalServerError, badge)
			return
		}
		c.String(http.StatusOK, badge)
	default:
		c.String(http.StatusNotFound, devhub.ErrBadge(left, fmt.Errorf("ambiguous name")))
	}
}
Example #5
0
// View handles the file views
func View(c *gin.Context) {
	var err error

	id := c.Param("uniuri")
	re := models.Resource{}

	if err = re.Get(id); err != nil || re.Key == "" {
		logger.InfoC(c, "server", "Not found", id)
		c.AbortWithStatus(http.StatusNotFound)
		return
	}
	re.LogFetched(c)
	f, err := os.Open(path.Join(conf.C.UploadDir, re.Key))
	if err != nil {
		logger.ErrC(c, "server", fmt.Sprintf("Couldn't open %s", re.Key), err)
		c.AbortWithStatus(http.StatusInternalServerError)
		return
	}
	if conf.C.AlwaysDownload {
		c.Header("Content-Type", "application/octet-stream")
	}
	c.Header("Content-Disposition", "filename=\""+re.Name+"\"")
	io.Copy(c.Writer, f)
	if re.Once {
		re.Delete()
		re.LogDeleted(c)
	}
}
Example #6
0
func Generate8bit(c *gin.Context) {
	name := c.Param("name")
	gender := c.Param("gender")

	switch {
	case gender == "m":
		gender = "male"
	case gender == "f":
		gender = "female"
	case gender == "male" || gender == "female":
		//do nothing
	default:
		c.AbortWithError(http.StatusInternalServerError, errors.New("Invalid parameters"))
		return
	}

	log.Println(name)
	InitAssets()
	img := GenerateIdenticon8bits(gender, []byte(name))
	c.Header("Content-Type", "image/png")
	c.Stream(func(w io.Writer) bool {
		png.Encode(w, img)
		return false
	})
}
Example #7
0
func Home(c *gin.Context) {
	input := Form{}
	if err := c.Bind(&input); err != nil {
		c.AbortWithError(http.StatusInternalServerError, err)
		return
	}

	if input.Attempt >= 3 {
		c.Redirect(http.StatusFound, "/goodbye")
		return
	}

	content := TwiML{
		Gather: &Gather{
			Action: fmt.Sprintf("/auth?Attempt=%d", input.Attempt),
			Method: "POST",
			Say:    "Please enter your authorization code",
		},
		Redirect: &Redirect{
			Method: "GET",
			Action: fmt.Sprintf("/?Attempt=%d", input.Attempt+1),
		},
	}
	c.Header("Content-Type", "text/xml")

	io.WriteString(c.Writer, `<?xml version="1.0" encoding="UTF-8" ?>`)
	xml.NewEncoder(c.Writer).Encode(content)
}
Example #8
0
// Discovery : templates the rkt discovery data
func (wh *WebHandler) Discovery(c *gin.Context) {
	logger.Debug(c.Request.RequestURI)
	logger.Debug(c.Request.Host)
	queryMap := c.Request.URL.Query()
	_, ok := queryMap["ac-discovery"]
	logger.Info("%v", queryMap)
	if ok {
		t := rktTmpl{}
		t.BaseIP = wh.config.BaseIP
		t.HostName = c.Request.Host
		t.AciName = c.Params.ByName("name")
		logger.Notice("Rocket file : %s", t.AciName)
		// random etags for the win
		c.Header("ETag", time.Now().String())
		err := tmpl.ExecuteTemplate(c.Writer, "rocket", t)
		if err != nil {
			logger.Error("template error ", err)
		}
		return
	} else {
		AciName := c.Params.ByName("name")
		fh, size, err := RocketACI.Get(AciName)
		if err != nil {
			logger.Error("Rocket file error : %s", err)
			c.AbortWithStatus(404)
		}
		logger.Notice("Serving ACI : %s", AciName)
		if size > 0 {
			c.Writer.Header().Set("Content-Length", strconv.FormatInt(size, 10))
		}
		io.Copy(c.Writer, fh)
	}
}
Example #9
0
func parse(c *gin.Context) {
	c.Header("Access-Control-Allow-Origin", "*")
	c.Header("Access-Control-Allow-Headers", "origin, content-type, accept")

	var json Request
	err := c.BindJSON(&json)
	if err != nil || json.Link == "" {
		c.JSON(http.StatusBadRequest, gin.H{"message": "Incrorrect request"})
		return
	}

	link := json.Link

	u, err := url.Parse(link)
	if err != nil {
		c.JSON(400, gin.H{"message": "Broken link", "link": link})
		return
	}

	id := insertUrl(u.String())

	go grab(u, id)

	c.JSON(http.StatusCreated, gin.H{"message": "processing", "id": id, "link": link})
}
Example #10
0
func (s *Sensorserver) GetChart(c *gin.Context) {

	// Load Template
	//  Can't use c.HTML(), because the html template function escape "
	t, _ := template.ParseFiles(s.conf.TemplateDir + "/chart.js")

	s.conf.Type = c.Param("type")

	durationInSeconds := s.duration(c.Query("duration"))

	f := make(map[string]interface{})
	for _, sensor := range s.conf.Sensors {
		data, err := s.fetchLastData(sensor, durationInSeconds)
		if err != nil {
			log.Println(err.Error())
			c.String(http.StatusInternalServerError, err.Error())
			return
		}

		if s.conf.Type == "single" {
			f[sensor] = s.reduceData(data)
		} else {
			f[sensor] = s.getMinMaxPerDay(data)
		}
	}

	f["plotBands"] = s.GetSunriseAndSunset()
	f["type"] = s.conf.Type

	c.Header("Content-Type", "application/javascript; charset=utf-8")
	t.Execute(c.Writer, f)
}
func (o *OptionsHandler) AuthJwt(c *gin.Context) {
	c.Header("Allow", "POST")

	c.JSON(http.StatusCreated, TasksOptions{
		"POST": Method{
			Description: "Check user credentials and return jwt token",
			Parameters: Parameters{
				Parameter{
					"username": ParameterOption{
						"type":        "string",
						"description": "Username",
						"required":    true,
					},
					"password": ParameterOption{
						"type":        "string",
						"description": "Password",
						"required":    true,
					},
				},
			},
			Example: map[string]interface{}{
				"username": "Bender",
				"password": "molly",
			},
		},
	})
}
Example #12
0
func (as ApiService) serviceCreate(c *gin.Context) {
	var newService types.Service
	if err := c.BindJSON(&newService); err != nil {
		c.Error(err)
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	//Guarantees that no one tries to create a destination together with a service
	newService.Destinations = []types.Destination{}

	if _, errs := govalidator.ValidateStruct(newService); errs != nil {
		c.Error(errs)
		c.JSON(http.StatusBadRequest, gin.H{"errors": govalidator.ErrorsByField(errs)})
		return
	}

	// If everthing is ok send it to Raft
	err := as.balancer.AddService(&newService)
	if err != nil {
		c.Error(err)
		if err == types.ErrServiceAlreadyExists {
			c.JSON(http.StatusConflict, gin.H{"error": err.Error()})
		} else {
			c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("UpsertService() failed: %v", err)})
		}
		return
	}

	c.Header("Location", fmt.Sprintf("/services/%s", newService.Name))
	c.JSON(http.StatusCreated, newService)
}
Example #13
0
func Dial(c *gin.Context) {
	c.Header("Content-Type", "text/xml")

	io.WriteString(c.Writer, `<?xml version="1.0" encoding="UTF-8" ?>
<Response>
	<Dial timeout="10">510-529-9511</Dial>
</Response>`)
}
Example #14
0
func IndexHtml(c *gin.Context) {
	html := createHtml("メニュー画面", []string{"/js/$c.js", "/js/$v.js", "/js/index.js", "/js/_cjsx.js", "/js/indexjsx.js"},
		[]string{"/js/lib/fluxxor.js", "/js/lib/react.js", "/js/lib/react-bootstrap.js",
			"/js/lib/jquery-1.11.1.js", "/js/lib/lodash.js"},
		[]string{"/css/bootstrap.css", "/css/main.css"}, []string{})
	c.Header("Content-Type", "text/html")
	c.String(200, html)
}
Example #15
0
func Buzz(c *gin.Context) {
	c.Header("Content-Type", "text/xml")

	io.WriteString(c.Writer, `<?xml version="1.0" encoding="UTF-8" ?>
<Response>
	<Play>/static/DTMF-9.mp3</Play>
	<Play>/static/DTMF-pound.mp3</Play>
</Response>`)
}
func (o *OptionsHandler) Tasks(c *gin.Context) {
	c.Header("Allow", "POST, PUT, DELETE")

	c.JSON(http.StatusCreated, TasksOptions{
		"POST": Method{
			Description: "Creates new task.",
			Parameters:  taskParameters,
			Example: map[string]interface{}{
				"Title":       "Test task",
				"Description": "Test description",
				"Priority":    1,
				"CompletedAt": time.Now().Format(time.RFC3339),
				"IsDeleted":   false,
				"IsCompleted": true,
			},
		},
		"PUT": Method{
			Description: "Updates task fields by task ID",
			Parameters: Parameters{
				Parameter{
					"taskId": ParameterOption{
						"type":        "int",
						"description": "Task id to update.",
						"required":    true,
					},
					"task": taskParameters,
				},
			},
			Example: map[string]interface{}{
				"taskId": 1,
				"task": map[string]interface{}{
					"Title":       "Test task",
					"Description": "Test description",
					"Priority":    1,
					"CompletedAt": time.Now().Format(time.RFC3339),
					"IsDeleted":   false,
					"IsCompleted": true,
				},
			},
		},
		"DELETE": Method{
			Description: "Mar task as deleted by task ID",
			Parameters: Parameters{
				Parameter{
					"id": ParameterOption{
						"type":        "int",
						"description": "Task ID to delete",
						"required":    true,
					},
				},
			},
			Example: map[string]int{
				"id": 1,
			},
		},
	})
}
func certHandler(c *gin.Context) {
	if strings.Contains(c.Request.UserAgent(), "Firefox") {
		c.Header("content-type", "application/x-x509-ca-cert")
		c.File("ca.cert.cer")
		return
	}
	noFirefoxTemplate.Execute(c.Writer, gin.H{
		"url": "http://" + c.Request.Host + c.Request.URL.String(),
	})
}
Example #18
0
// GET http://localhost:8080/users/1
//
func (u UserResource) findUser(c *gin.Context) {
	log.Println("Request from User: ", c.MustGet("user"))
	id := c.Param("user-id")
	usr := u.users[id]
	if len(usr.Id) == 0 {
		c.Header("Content-Type", "text/plain")
		c.AbortWithError(http.StatusNotFound, new(ErrorUserNotFound))
		return
	}
	c.JSON(http.StatusOK, usr)
}
Example #19
0
func (s *DefaultServer) commandSpeedTest(c *gin.Context, args Args) {
	size := args.GetInt64(argTestSize)
	if size <= 0 || size > size100MB {
		size = size100MB
	}
	c.Header(headerContentLength, strconv.FormatInt(size, intBase))
	_, err := io.CopyN(c.Writer, speedTest{}, size)
	if err != nil {
		log.Println("speed test error", err)
	}
}
Example #20
0
func (auth *UserAuthenticator) BasicAuthForUser(c *gin.Context) bool {
	u, p, _ := c.Request.BasicAuth()
	if auth.AuthenticateUser(u, p) {
		return true
	}

	c.Header("WWW-Authenticate", "Basic realm=\"Status Dashboard\"")
	c.String(http.StatusUnauthorized, "Login required.")
	c.Abort()

	return false
}
Example #21
0
func getJob(c *gin.Context) {
	c.Header("Access-Control-Allow-Origin", "*")
	c.Header("Access-Control-Allow-Headers", "origin, content-type, accept")
	id := c.Param("id")
	json, err := selectJob(id)
	if err != nil {
		c.JSON(http.StatusNotFound, gin.H{"message": "error", "error": err})
		return
	}

	c.JSON(http.StatusOK, json)
}
Example #22
0
File: header.go Project: Ablu/drone
// Options is a middleware function that appends headers
// for options requests and aborts then exits the middleware
// chain and ends the request.
func Options(c *gin.Context) {
	if c.Request.Method != "OPTIONS" {
		c.Next()
	} else {
		c.Header("Access-Control-Allow-Origin", "*")
		c.Header("Access-Control-Allow-Methods", "GET,POST,PUT,PATCH,DELETE,OPTIONS")
		c.Header("Access-Control-Allow-Headers", "authorization, origin, content-type, accept")
		c.Header("Allow", "HEAD,GET,POST,PUT,PATCH,DELETE,OPTIONS")
		c.Header("Content-Type", "application/json")
		c.AbortWithStatus(200)
	}
}
Example #23
0
func (this GamesController) Create(ginContext *gin.Context) {
	game, err := models.Game{}.Create(this.Context.AeContext, this.Player())

	game.Url = this.ResourceUrl(baseURL, game.Id)

	if err.Any() {
		this.RespondWith.UnexpectedError(err)
		return
	}

	ginContext.Header("location", game.Url)
	ginContext.JSON(http.StatusCreated, game)
}
Example #24
0
func GenerateGitHub(c *gin.Context, name string, width, margin int) {
	if width < 32 || width-margin < 10 {
		c.AbortWithError(http.StatusInternalServerError, errors.New("Invalid parameters"))
		return
	}

	img := GenerateIdenticon([]byte(name), width, margin)
	c.Header("Content-Type", "image/png")
	c.Stream(func(w io.Writer) bool {
		png.Encode(w, img)
		return false
	})
}
Example #25
0
func (mw *GinJWTMiddleware) unauthorized(c *gin.Context, code int, message string) {

	if mw.Realm == "" {
		mw.Realm = "gin jwt"
	}

	c.Header("WWW-Authenticate", "JWT realm="+mw.Realm)
	c.Abort()

	mw.Unauthorized(c, code, message)

	return
}
Example #26
0
func (s *MockServer) fire(mock Mock, i int, c *gin.Context) {
	s.mutex.Lock()
	s.Mocks[i].Count = s.Mocks[i].Count + 1
	s.mutex.Unlock()

	for header, val := range mock.HttpResponse.Headers {
		c.Header(header, val)
	}
	c.String(
		mock.HttpResponse.StatusCode,
		mock.HttpResponse.Body,
	)
}
Example #27
0
func (ar *APIResource) Authenticate(c *gin.Context) {
	var u models.User
	err := json.NewDecoder(c.Request.Body).Decode(&u)
	if err != nil {
		log.Printf("Error decoding JSON: %s\n", err)
	}
	if u.Auth() {
		ar.Authenticated = true
		c.Header("Authorization", "authenticated")
	} else {
		c.Error(errors.New("Failed to authenticate"))
		c.String(http.StatusForbidden, "Failed to authenticate")
	}
}
Example #28
0
func (s *Server) handleAPINodes(c *gin.Context) {
	result := make(nodeResponseList, 0)

	for _, n := range s.config.Poller.Nodes {
		result = append(result, nodeResponse{
			Name:  n.Name,
			Label: n.Label,
		})
	}

	sort.Sort(result)

	c.Header("Cache-Control", "private, max-age=0")
	c.JSON(http.StatusOK, result)
}
Example #29
0
func stop(c *gin.Context) {
	agentID := c.Param("agentID")

	a, _ := mdb.GetAgent(agentID)
	resp, _ := http.Post("http://"+a.IP+":"+a.Port+"/"+APIBASE+"/stop", "application/json", c.Request.Body)

	c.Header("Access-Control-Allow-Origin", "*")
	c.Header("Access-Control-Allow-Headers", "access-control-allow-origin, access-control-allow-headers")
	if resp.StatusCode != 200 {
		c.JSON(resp.StatusCode, resp.Body)
		return
	}

	c.JSON(resp.StatusCode, Message{"Container stopped."})
}
Example #30
0
func (s *Server) handleAPIHosts(c *gin.Context) {
	hs := set.New(set.ThreadSafe)

	// Get hosts list
	hosts, _ := s.poller.GetHosts()
	for _, h := range hosts {
		hs.Add(h.Name)
	}

	// Get unique set of hosts names
	result := set.StringSlice(hs)
	sort.Strings(result)

	c.Header("Cache-Control", "private, max-age=0")
	c.JSON(http.StatusOK, result)
}