func CreateDashboardSnapshot(c *middleware.Context, cmd m.CreateDashboardSnapshotCommand) { if cmd.External { // external snapshot ref requires key and delete key if cmd.Key == "" || cmd.DeleteKey == "" { c.JsonApiErr(400, "Missing key and delete key for external snapshot", nil) return } cmd.OrgId = -1 cmd.UserId = -1 metrics.M_Api_Dashboard_Snapshot_External.Inc(1) } else { cmd.Key = util.GetRandomString(32) cmd.DeleteKey = util.GetRandomString(32) cmd.OrgId = c.OrgId cmd.UserId = c.UserId metrics.M_Api_Dashboard_Snapshot_Create.Inc(1) } if err := bus.Dispatch(&cmd); err != nil { c.JsonApiErr(500, "Failed to create snaphost", err) return } c.JSON(200, util.DynMap{ "key": cmd.Key, "deleteKey": cmd.DeleteKey, "url": setting.ToAbsUrl("dashboard/snapshot/" + cmd.Key), "deleteUrl": setting.ToAbsUrl("api/snapshots-delete/" + cmd.DeleteKey), }) }
func CreateUser(cmd *m.CreateUserCommand) error { return inTransaction2(func(sess *session) error { orgId, err := getOrgIdForNewUser(cmd.Email, sess) if err != nil { return err } // create user user := m.User{ Email: cmd.Email, Name: cmd.Name, Login: cmd.Login, Company: cmd.Company, IsAdmin: cmd.IsAdmin, OrgId: orgId, Created: time.Now(), Updated: time.Now(), } if len(cmd.Password) > 0 { user.Salt = util.GetRandomString(10) user.Rands = util.GetRandomString(10) user.Password = util.EncodePassword(cmd.Password, user.Salt) } sess.UseBool("is_admin") if _, err := sess.Insert(&user); err != nil { return err } // create org user link orgUser := m.OrgUser{ OrgId: orgId, UserId: user.Id, Role: m.ROLE_ADMIN, Created: time.Now(), Updated: time.Now(), } if setting.AutoAssignOrg && !user.IsAdmin { orgUser.Role = m.RoleType(setting.AutoAssignOrgRole) } if _, err = sess.Insert(&orgUser); err != nil { return err } sess.publishAfterCommit(&events.UserCreated{ Timestamp: user.Created, Id: user.Id, Name: user.Name, Login: user.Login, Email: user.Email, }) cmd.Result = user return nil }) }
// POST /api/user/signup func SignUp(c *middleware.Context, form dtos.SignUpForm) Response { if !setting.AllowUserSignUp { return ApiError(401, "User signup is disabled", nil) } existing := m.GetUserByLoginQuery{LoginOrEmail: form.Email} if err := bus.Dispatch(&existing); err == nil { return ApiError(422, "User with same email address already exists", nil) } cmd := m.CreateTempUserCommand{} cmd.OrgId = -1 cmd.Email = form.Email cmd.Status = m.TmpUserSignUpStarted cmd.InvitedByUserId = c.UserId cmd.Code = util.GetRandomString(20) cmd.RemoteAddr = c.Req.RemoteAddr if err := bus.Dispatch(&cmd); err != nil { return ApiError(500, "Failed to create signup", err) } bus.Publish(&events.SignUpStarted{ Email: form.Email, Code: cmd.Code, }) metrics.M_Api_User_SignUpStarted.Inc(1) return Json(200, util.DynMap{"status": "SignUpCreated"}) }
func RenderToPng(params *RenderOpts) (string, error) { rendererLog.Info("Rendering", "url", params.Url) var executable = "phantomjs" if runtime.GOOS == "windows" { executable = executable + ".exe" } binPath, _ := filepath.Abs(filepath.Join(setting.PhantomDir, executable)) scriptPath, _ := filepath.Abs(filepath.Join(setting.PhantomDir, "render.js")) pngPath, _ := filepath.Abs(filepath.Join(setting.ImagesDir, util.GetRandomString(20))) pngPath = pngPath + ".png" cmd := exec.Command(binPath, "--ignore-ssl-errors=true", scriptPath, "url="+params.Url, "width="+params.Width, "height="+params.Height, "png="+pngPath, "cookiename="+setting.SessionOptions.CookieName, "domain="+setting.Domain, "sessionid="+params.SessionId) stdout, err := cmd.StdoutPipe() if err != nil { return "", err } stderr, err := cmd.StderrPipe() if err != nil { return "", err } err = cmd.Start() if err != nil { return "", err } go io.Copy(os.Stdout, stdout) go io.Copy(os.Stdout, stderr) done := make(chan error) go func() { cmd.Wait() close(done) }() timeout, err := strconv.Atoi(params.Timeout) if err != nil { timeout = 15 } select { case <-time.After(time.Duration(timeout) * time.Second): if err := cmd.Process.Kill(); err != nil { rendererLog.Error("failed to kill", "error", err) } return "", fmt.Errorf("PhantomRenderer::renderToPng timeout (>%vs)", timeout) case <-done: } rendererLog.Debug("Image rendered", "path", pngPath) return pngPath, nil }
func AddOrgInvite(c *middleware.Context, inviteDto dtos.AddInviteForm) Response { logger := log.New("main") logger.Info(" AddOrgInvite1", c.OrgId) if !inviteDto.Role.IsValid() { return ApiError(400, "Invalid role specified", nil) } // first try get existing user userQuery := m.GetUserByLoginQuery{LoginOrEmail: inviteDto.LoginOrEmail} if err := bus.Dispatch(&userQuery); err != nil { if err != m.ErrUserNotFound { return ApiError(500, "Failed to query db for existing user check", err) } } else { return inviteExistingUserToOrg(c, userQuery.Result, &inviteDto) } logger1 := log.New("main") logger1.Info(" AddOrgInvite2", c.OrgId) cmd := m.CreateTempUserCommand{} cmd.OrgId = c.OrgId cmd.Email = inviteDto.LoginOrEmail cmd.Name = inviteDto.Name cmd.Status = m.TmpUserInvitePending cmd.InvitedByUserId = c.UserId cmd.Code = util.GetRandomString(30) cmd.Role = inviteDto.Role cmd.RemoteAddr = c.Req.RemoteAddr if err := bus.Dispatch(&cmd); err != nil { return ApiError(500, "Failed to save invite to database", err) } // send invite email if !inviteDto.SkipEmails && util.IsEmail(inviteDto.LoginOrEmail) { emailCmd := m.SendEmailCommand{ To: []string{inviteDto.LoginOrEmail}, Template: "new_user_invite.html", Data: map[string]interface{}{ "Name": util.StringsFallback2(cmd.Name, cmd.Email), "OrgName": c.OrgName, "Email": c.Email, "LinkUrl": setting.ToAbsUrl("invite/" + cmd.Code), "InvitedBy": util.StringsFallback3(c.Name, c.Email, c.Login), }, } if err := bus.Dispatch(&emailCmd); err != nil { return ApiError(500, "Failed to send email invite", err) } return ApiSuccess(fmt.Sprintf("Sent invite to %s", inviteDto.LoginOrEmail)) } return ApiSuccess(fmt.Sprintf("Created invite for %s", inviteDto.LoginOrEmail)) }
func AddRenderAuthKey(orgId int64) string { renderKeysLock.Lock() key := util.GetRandomString(32) renderKeys[key] = &m.SignedInUser{ OrgId: orgId, OrgRole: m.ROLE_VIEWER, } renderKeysLock.Unlock() return key }
func New(orgId int64, name string) KeyGenResult { jsonKey := ApiKeyJson{} jsonKey.OrgId = orgId jsonKey.Name = name jsonKey.Key = util.GetRandomString(32) result := KeyGenResult{} result.HashedKey = util.EncodePassword(jsonKey.Key, name) jsonString, _ := json.Marshal(jsonKey) result.ClientSecret = base64.StdEncoding.EncodeToString([]byte(jsonString)) return result }
func RenderToPng(params *RenderOpts) (string, error) { log.Info("PhantomRenderer::renderToPng url %v", params.Url) binPath, _ := filepath.Abs(filepath.Join(setting.PhantomDir, "phantomjs")) scriptPath, _ := filepath.Abs(filepath.Join(setting.PhantomDir, "render.js")) pngPath, _ := filepath.Abs(filepath.Join(setting.ImagesDir, util.GetRandomString(20))) pngPath = pngPath + ".png" cmd := exec.Command(binPath, "--ignore-ssl-errors=true", scriptPath, "url="+params.Url, "width="+params.Width, "height="+params.Height, "png="+pngPath, "cookiename="+setting.SessionOptions.CookieName, "domain="+setting.Domain, "sessionid="+params.SessionId) stdout, err := cmd.StdoutPipe() if err != nil { return "", err } stderr, err := cmd.StderrPipe() if err != nil { return "", err } err = cmd.Start() if err != nil { return "", err } go io.Copy(os.Stdout, stdout) go io.Copy(os.Stdout, stderr) done := make(chan error) go func() { cmd.Wait() close(done) }() select { case <-time.After(15 * time.Second): if err := cmd.Process.Kill(); err != nil { log.Error(4, "failed to kill: %v", err) } case <-done: } return pngPath, nil }
func (u *WebdavUploader) Upload(pa string) (string, error) { client := http.Client{Timeout: time.Duration(10 * time.Second)} url, _ := url.Parse(u.url) url.Path = path.Join(url.Path, util.GetRandomString(20)+".png") imgData, err := ioutil.ReadFile(pa) req, err := http.NewRequest("PUT", url.String(), bytes.NewReader(imgData)) res, err := client.Do(req) if err != nil { return "", err } if res.StatusCode != http.StatusCreated { body, _ := ioutil.ReadAll(res.Body) return "", fmt.Errorf("Failed to upload image. Returned statuscode %v body %s", res.StatusCode, body) } return url.String(), nil }
func (u *S3Uploader) Upload(imageDiskPath string) (string, error) { s3util.DefaultConfig.AccessKey = u.accessKey s3util.DefaultConfig.SecretKey = u.secretKey header := make(http.Header) header.Add("x-amz-acl", "public-read") header.Add("Content-Type", "image/png") var imageUrl *url.URL var err error if imageUrl, err = url.Parse(u.bucket); err != nil { return "", err } // add image to url imageUrl.Path = path.Join(imageUrl.Path, util.GetRandomString(20)+".png") imageUrlString := imageUrl.String() log.Debug("Uploading image to s3", "url", imageUrlString) writer, err := s3util.Create(imageUrlString, header, nil) if err != nil { return "", err } defer writer.Close() imgData, err := ioutil.ReadFile(imageDiskPath) if err != nil { return "", err } _, err = writer.Write(imgData) if err != nil { return "", err } return imageUrlString, nil }
func (u *S3Uploader) Upload(imageDiskPath string) (string, error) { sess := session.New() creds := credentials.NewChainCredentials( []credentials.Provider{ &credentials.StaticProvider{Value: credentials.Value{ AccessKeyID: u.accessKey, SecretAccessKey: u.secretKey, }}, &credentials.EnvProvider{}, &ec2rolecreds.EC2RoleProvider{Client: ec2metadata.New(sess), ExpiryWindow: 5 * time.Minute}, }) cfg := &aws.Config{ Region: aws.String(u.region), Credentials: creds, } key := util.GetRandomString(20) + ".png" log.Debug("Uploading image to s3", "bucket = ", u.bucket, ", key = ", key) file, err := os.Open(imageDiskPath) if err != nil { return "", err } svc := s3.New(session.New(cfg), cfg) params := &s3.PutObjectInput{ Bucket: aws.String(u.bucket), Key: aws.String(key), ACL: aws.String(u.acl), Body: file, ContentType: aws.String("image/png"), } _, err = svc.PutObject(params) if err != nil { return "", err } return "https://" + u.bucket + ".s3.amazonaws.com/" + key, nil }
func (u *WebdavUploader) Upload(pa string) (string, error) { url, _ := url.Parse(u.url) url.Path = path.Join(url.Path, util.GetRandomString(20)+".png") imgData, err := ioutil.ReadFile(pa) req, err := http.NewRequest("PUT", url.String(), bytes.NewReader(imgData)) if u.username != "" { req.SetBasicAuth(u.username, u.password) } res, err := http.DefaultClient.Do(req) if err != nil { return "", err } if res.StatusCode != http.StatusCreated { body, _ := ioutil.ReadAll(res.Body) return "", fmt.Errorf("Failed to upload image. Returned statuscode %v body %s", res.StatusCode, body) } return url.String(), nil }
func RenderToPng(params *RenderOpts) (string, error) { rendererLog.Info("Rendering", "path", params.Path) var executable = "phantomjs" if runtime.GOOS == "windows" { executable = executable + ".exe" } localDomain := "localhost" if setting.HttpAddr != setting.DEFAULT_HTTP_ADDR { localDomain = setting.HttpAddr } url := fmt.Sprintf("%s://%s:%s/%s", setting.Protocol, localDomain, setting.HttpPort, params.Path) binPath, _ := filepath.Abs(filepath.Join(setting.PhantomDir, executable)) scriptPath, _ := filepath.Abs(filepath.Join(setting.PhantomDir, "render.js")) pngPath, _ := filepath.Abs(filepath.Join(setting.ImagesDir, util.GetRandomString(20))) pngPath = pngPath + ".png" renderKey := middleware.AddRenderAuthKey(params.OrgId) defer middleware.RemoveRenderAuthKey(renderKey) cmdArgs := []string{ "--ignore-ssl-errors=true", "--web-security=false", scriptPath, "url=" + url, "width=" + params.Width, "height=" + params.Height, "png=" + pngPath, "domain=" + localDomain, "renderKey=" + renderKey, } cmd := exec.Command(binPath, cmdArgs...) stdout, err := cmd.StdoutPipe() if err != nil { return "", err } stderr, err := cmd.StderrPipe() if err != nil { return "", err } err = cmd.Start() if err != nil { return "", err } go io.Copy(os.Stdout, stdout) go io.Copy(os.Stdout, stderr) done := make(chan error) go func() { cmd.Wait() close(done) }() timeout, err := strconv.Atoi(params.Timeout) if err != nil { timeout = 15 } select { case <-time.After(time.Duration(timeout) * time.Second): if err := cmd.Process.Kill(); err != nil { rendererLog.Error("failed to kill", "error", err) } return "", fmt.Errorf("PhantomRenderer::renderToPng timeout (>%vs)", timeout) case <-done: } rendererLog.Debug("Image rendered", "path", pngPath) return pngPath, nil }