Example #1
0
// AddDir adds a directory to be watched, returning an error if any.
// It allows a filter to be specified on which files to watch.
// It also allows recursive watching.
func (fw *FileSystemWatcher) AddDir(path, pattern string, ops Op, recursive bool) error {

	// Add the given path to be watched. addDir will perform checking for us to
	// ensure that the path really is a directory.
	err := fw.addDir(path, pattern, ops)
	if err != nil {
		return stackerr.Wrap(err)
	}

	if recursive {
		err = filepath.Walk(path, func(p string, info os.FileInfo, err error) error {
			if info.IsDir() {
				// Subdirectories inherit the filename pattern and ops from the parent.
				if e := fw.addDir(p, pattern, ops); err != nil {
					return stackerr.Wrap(e)
				}
			}
			return nil
		})
		if err != nil {
			return err
		}
	}

	return nil
}
Example #2
0
func (l *login) updatedNetrcContent(
	e *env,
	content io.Reader,
	credentials *credentials,
) ([]byte, error) {
	tokens, err := netrc.Parse(content)
	if err != nil {
		return nil, stackerr.Wrap(err)
	}

	server, err := getHostFromURL(e.Server)
	if err != nil {
		return nil, err
	}
	machine := tokens.FindMachine(server)
	if machine == nil {
		machine = tokens.NewMachine(server, "default", credentials.token, "")
	} else {
		machine.UpdatePassword(credentials.token)
	}

	updatedContent, err := tokens.MarshalText()
	if err != nil {
		return nil, stackerr.Wrap(err)
	}
	return updatedContent, nil
}
Example #3
0
func (l *logsCmd) round(e *env, c *context, startTime *parseTime) (*parseTime, error) {
	v := make(url.Values)
	v.Set("n", fmt.Sprint(l.num))
	v.Set("level", l.level)

	if startTime != nil {
		b, err := json.Marshal(startTime)
		if err != nil {
			return nil, stackerr.Wrap(err)
		}
		v.Set("startTime", string(b))
	}

	u := &url.URL{
		Path:     "scriptlog",
		RawQuery: v.Encode(),
	}
	var rows []logResponse
	if _, err := e.ParseAPIClient.Get(u, &rows); err != nil {
		return nil, stackerr.Wrap(err)
	}
	// logs come back in reverse
	for i := len(rows) - 1; i >= 0; i-- {
		fmt.Fprintln(e.Out, rows[i].Message)
	}
	if len(rows) > 0 {
		return &rows[0].Timestamp, nil
	}
	return startTime, nil
}
Example #4
0
func (h *functionHooksCmd) functionHooksCreate(e *parsecli.Env, ctx *parsecli.Context) error {
	params, err := readFunctionParams(e, h.Function)
	if err != nil {
		return err
	}

	var res functionHook
	functionsURL, err := url.Parse(defaultFunctionsURL)
	if err != nil {
		return stackerr.Wrap(err)
	}
	_, err = e.ParseAPIClient.Post(functionsURL, params, &res)
	if err != nil {
		return stackerr.Wrap(err)
	}
	if res.Warning != "" {
		fmt.Fprintf(e.Err, "WARNING: %s\n", res.Warning)
	}

	fmt.Fprintf(e.Out,
		"Successfully created a webhook function %q pointing to %q\n",
		res.FunctionName,
		res.URL,
	)
	return nil
}
Example #5
0
func writeProjectConfig(p *projectConfig, path string) error {
	b, err := json.MarshalIndent(p, "", "  ")
	if err != nil {
		return stackerr.Wrap(err)
	}
	return stackerr.Wrap(ioutil.WriteFile(path, b, 0600))
}
Example #6
0
func (s *UserService) create(req *restful.Request, resp *restful.Response) {
	// TODO (m0sth8): Check permissions
	raw := &user.User{}

	if err := req.ReadEntity(raw); err != nil {
		logrus.Error(stackerr.Wrap(err))
		resp.WriteServiceError(http.StatusBadRequest, services.WrongEntityErr)
		return
	}

	mgr := s.Manager()
	defer mgr.Close()

	obj, err := mgr.Users.Create(raw)
	if err != nil {
		if mgr.IsDup(err) {
			resp.WriteServiceError(
				http.StatusConflict,
				services.NewError(services.CodeDuplicate, "user with this email is existed"))
			return
		}
		logrus.Error(stackerr.Wrap(err))
		resp.WriteServiceError(http.StatusInternalServerError, services.DbErr)
		return
	}

	resp.WriteHeader(http.StatusCreated)
	resp.WriteEntity(obj)
}
Example #7
0
func (h *functionHooksCmd) functionHooksUpdate(e *parsecli.Env, ctx *parsecli.Context) error {
	params, err := readFunctionParams(e, h.Function)
	if err != nil {
		return err
	}
	var res functionHook
	functionsURL, err := url.Parse(path.Join(defaultFunctionsURL, params.FunctionName))
	if err != nil {
		return stackerr.Wrap(err)
	}

	_, err = e.ParseAPIClient.Put(functionsURL, &functionHook{URL: params.URL}, &res)
	if err != nil {
		return stackerr.Wrap(err)
	}
	if res.Warning != "" {
		fmt.Fprintf(e.Err, "WARNING: %s\n", res.Warning)
	}

	fmt.Fprintf(e.Out,
		"Successfully update the webhook function %q to point to %q\n",
		res.FunctionName,
		res.URL,
	)
	return nil
}
Example #8
0
func (h *triggerHooksCmd) triggerHooksUpdate(e *env, ctx *context) error {
	params, err := readTriggerParams(e, h.Trigger)
	if err != nil {
		return err
	}
	var res triggerHook
	triggersURL, err := url.Parse(path.Join(defaultTriggersURL, params.ClassName, params.TriggerName))
	if err != nil {
		return stackerr.Wrap(err)
	}
	_, err = e.ParseAPIClient.Put(triggersURL, &triggerHook{URL: params.URL}, &res)
	if err != nil {
		return stackerr.Wrap(err)
	}
	if res.Warning != "" {
		fmt.Fprintf(e.Err, "WARNING: %s\n", res.Warning)
	}
	fmt.Fprintf(e.Out,
		"Successfully update the %q trigger for class %q to point to %q\n",
		res.TriggerName,
		res.ClassName,
		res.URL,
	)

	return nil
}
Example #9
0
func (h *triggerHooksCmd) triggerHooksDelete(e *env, ctx *context) error {
	params, err := readTriggerName(e, h.Trigger)
	if err != nil {
		return err
	}
	triggersURL, err := url.Parse(path.Join(defaultTriggersURL, params.ClassName, params.TriggerName))
	if err != nil {
		return stackerr.Wrap(err)
	}

	confirmMessage := fmt.Sprintf("Are you sure you want to delete %q webhook trigger for class: %q (y/n): ",
		params.TriggerName,
		params.ClassName,
	)

	var res triggerHook
	if !h.interactive || getConfirmation(confirmMessage, e) {
		_, err = e.ParseAPIClient.Put(triggersURL, map[string]interface{}{"__op": "Delete"}, &res)
		if err != nil {
			return stackerr.Wrap(err)
		}
		fmt.Fprintf(e.Out, "Successfully deleted %q webhook trigger for class %q\n",
			params.TriggerName,
			params.ClassName,
		)
		if res.TriggerName != "" && res.ClassName != "" {
			fmt.Fprintf(e.Out, "%q trigger defined in cloudcode for class %q will be used henceforth\n",
				res.TriggerName,
				res.ClassName,
			)
		}
	}
	return nil
}
Example #10
0
// BestEfforDockerClient creates a docker client from one of:
//
// 1. Environment variables as defined in
//    https://docs.docker.com/reference/commandline/cli/. Specifically
//    DOCKER_HOST, DOCKER_TLS_VERIFY & DOCKER_CERT_PATH.
//
// 2. bootdocker, if darwin.
//
// 3. /run/docker.sock, if it exists.
//
// 4. /var/run/docker.sock, if it exists.
func BestEffortDockerClient() (*dockerclient.DockerClient, error) {
	host := os.Getenv("DOCKER_HOST")

	if host == "" {
		if runtime.GOOS == "darwin" {
			return Boot2DockerClient()
		}

		socketLocations := []string{"/run/docker.sock", "/var/run/docker.sock"}
		for _, l := range socketLocations {
			if _, err := os.Stat(l); err == nil {
				c, err := dockerclient.NewDockerClient(fmt.Sprintf("unix://%s", l), nil)
				if err != nil {
					return nil, stackerr.Wrap(err)
				}
				return c, nil
			}
		}

		return nil, stackerr.New("docker not configured")
	}

	if os.Getenv("DOCKER_TLS_VERIFY") != "" {
		return DockerWithTLS(host, os.Getenv("DOCKER_CERT_PATH"))
	}

	c, err := dockerclient.NewDockerClient(host, nil)
	if err != nil {
		return nil, stackerr.Wrap(err)
	}

	return c, nil
}
Example #11
0
// DockerWithTLS returns a DockerClient with the certs in the specified
// directory. The names of the certs are the standard names of "cert.pem",
// "key.pem" and "ca.pem".
func DockerWithTLS(url, certPath string) (*dockerclient.DockerClient, error) {
	var tlsConfig *tls.Config
	clientCert, err := tls.LoadX509KeyPair(
		filepath.Join(certPath, "cert.pem"),
		filepath.Join(certPath, "key.pem"),
	)
	if err != nil {
		return nil, stackerr.Wrap(err)
	}

	rootCAs := x509.NewCertPool()
	caCert, err := ioutil.ReadFile(filepath.Join(certPath, "ca.pem"))
	if err != nil {
		return nil, stackerr.Wrap(err)
	}
	rootCAs.AppendCertsFromPEM(caCert)

	tlsConfig = &tls.Config{
		Certificates: []tls.Certificate{clientCert},
		RootCAs:      rootCAs,
	}
	client, err := dockerclient.NewDockerClient(url, tlsConfig)
	if err != nil {
		return nil, stackerr.Wrap(err)
	}
	return client, nil
}
Example #12
0
// disabled
func (s *ScanService) update(req *restful.Request, resp *restful.Response, pl *scan.Scan) {
	// TODO (m0sth8): Check permissions
	// TODO (m0sth8): Forbid changes in scan after finished status

	raw := &scan.Scan{}

	if err := req.ReadEntity(raw); err != nil {
		logrus.Error(stackerr.Wrap(err))
		resp.WriteServiceError(http.StatusBadRequest, services.WrongEntityErr)
		return
	}
	mgr := s.Manager()
	defer mgr.Close()

	raw.Id = pl.Id

	if err := mgr.Scans.Update(raw); err != nil {
		if mgr.IsNotFound(err) {
			resp.WriteErrorString(http.StatusNotFound, "Not found")
			return
		}
		if mgr.IsDup(err) {
			resp.WriteServiceError(
				http.StatusConflict,
				services.NewError(services.CodeDuplicate, "scan with this name and version is existed"))
			return
		}
		logrus.Error(stackerr.Wrap(err))
		resp.WriteServiceError(http.StatusInternalServerError, services.DbErr)
		return
	}

	resp.WriteHeader(http.StatusOK)
	resp.WriteEntity(raw)
}
Example #13
0
// create file with data
func (m *FileManager) Create(r io.Reader, metaInfo *file.Meta) (*file.Meta, error) {
	f, err := m.grid.Create("")
	// according to gridfs code, the error here is impossible
	if err != nil {
		return nil, stackerr.Wrap(err)
	}
	size, err := io.Copy(f, r)
	if err != nil {
		return nil, stackerr.Wrap(err)
	}
	meta := &file.Meta{
		Id:          file.UniqueFileId(),
		Size:        int(size),
		ContentType: metaInfo.ContentType,
		Name:        metaInfo.Name,
	}
	f.SetId(meta.Id)
	f.SetMeta(meta)
	if meta.ContentType != "" {
		f.SetContentType(meta.ContentType)
	}
	if err = f.Close(); err != nil {
		return nil, stackerr.Wrap(err)
	}
	return meta, nil
}
Example #14
0
func (c *configureCmd) deleteHook(
	e *env,
	hooksOps []*hookOperation,
	fields ...string,
) (bool, []*hookOperation, error) {
	restOp := strings.ToUpper(fields[0])
	if restOp != "DELETE" {
		return false, nil, stackerr.Wrap(errInvalidFormat)
	}

	switch len(fields) {
	case 2:
		hooksOps = append(hooksOps, &hookOperation{
			method:   "DELETE",
			function: &functionHook{FunctionName: fields[1]},
		})
		return true, hooksOps, nil
	case 3:
		if err := c.checkTriggerName(fields[2]); err != nil {
			return false, nil, err
		}
		hooksOps = append(hooksOps, &hookOperation{
			method:  "DELETE",
			trigger: &triggerHook{ClassName: fields[1], TriggerName: fields[2]},
		})
		return true, hooksOps, nil
	}

	return false, nil, stackerr.Wrap(errInvalidFormat)
}
Example #15
0
func send(s mangos.Socket, obj interface{}) error {
	data, err := json.Marshal(obj)
	if err != nil {
		return stackerr.Wrap(err)
	}
	return stackerr.Wrap(s.Send(data))
}
Example #16
0
func (h *triggerHooksCmd) triggerHooksCreate(e *env, ctx *context) error {
	params, err := readTriggerParams(e, h.Trigger)
	if err != nil {
		return err
	}
	var res triggerHook
	triggersURL, err := url.Parse(defaultTriggersURL)
	if err != nil {
		return stackerr.Wrap(err)
	}
	_, err = e.ParseAPIClient.Post(triggersURL, params, &res)
	if err != nil {
		return stackerr.Wrap(err)
	}
	if res.Warning != "" {
		fmt.Fprintf(e.Err, "WARNING: %s\n", res.Warning)
	}
	fmt.Fprintf(e.Out,
		"Successfully created a %q trigger for class %q pointing to %q\n",
		res.TriggerName,
		res.ClassName,
		res.URL,
	)
	return nil
}
Example #17
0
func recv(s mangos.Socket, obj interface{}) error {
	data, err := s.Recv()
	if err != nil {
		return stackerr.Wrap(err)
	}
	return stackerr.Wrap(json.Unmarshal(data, obj))
}
Example #18
0
func (g *Generator) genForNames(names string) error {
	certFileName := "cert.pem"
	keyFileName := "key.pem"

	rootCert, err := g.loadRootCA()
	if err != nil {
		return err
	}

	rootKey, err := g.loadRootCAKey()
	if err != nil {
		return err
	}

	priv, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		return stackerr.Wrap(err)
	}

	now := time.Now()

	template := x509.Certificate{
		SerialNumber: new(big.Int).SetInt64(0),
		Subject: pkix.Name{
			CommonName: names,
		},
		NotBefore:             now.Add(-5 * time.Minute).UTC(),
		NotAfter:              now.Add(g.MaxAge),
		SubjectKeyId:          []byte{1, 2, 3, 4},
		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
		BasicConstraintsValid: true,
	}

	derBytes, err := x509.CreateCertificate(
		rand.Reader, &template, rootCert, &priv.PublicKey, rootKey)
	if err != nil {
		return stackerr.Wrap(err)
	}

	certOut, err := os.Create(certFileName)
	if err != nil {
		return stackerr.Wrap(err)
	}
	pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
	certOut.Close()
	log.Print("Written " + certFileName + "\n")

	keyOut, err := os.OpenFile(keyFileName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
	if err != nil {
		return stackerr.Wrap(err)
	}
	pem.Encode(keyOut, &pem.Block{
		Type:  "RSA PRIVATE KEY",
		Bytes: x509.MarshalPKCS1PrivateKey(priv),
	})
	keyOut.Close()
	log.Print("Written " + keyFileName + "\n")
	return nil
	return nil
}
Example #19
0
func (d *downloadCmd) run(e *env, c *context) error {
	var err error

	latestRelease := d.release
	if latestRelease == nil {
		latestRelease, err = (&deployCmd{}).getPrevDeplInfo(e)
		if err != nil {
			return err
		}
		if len(latestRelease.Versions.Cloud) == 0 && len(latestRelease.Versions.Public) == 0 {
			return errNoFiles
		}
	}

	destination := d.destination
	if destination == "" {
		destination, err = ioutil.TempDir("", "parse_code_")
		if err != nil {
			return stackerr.Wrap(err)
		}
	}

	err = d.download(e, destination, latestRelease)
	if err != nil {
		fmt.Fprintln(e.Err, "Failed to download Cloud Code.")
		return stackerr.Wrap(err)
	}
	if !d.force {
		fmt.Fprintf(e.Out, "Successfully downloaded Cloud Code to %q.\n", destination)
		return nil
	}

	return stackerr.Wrap(d.moveFiles(e, destination, latestRelease))
}
func (i *iosSymbolUploader) convertSymbols(e *env) ([]string, error) {
	homedir, err := homedir.Dir()
	if err != nil {
		return nil, stackerr.Wrap(err)
	}

	folderPath := filepath.Join(homedir, ".parse", "CrashReportingSymbols")
	if err := i.prepareSymbolsFolder(folderPath, e); err != nil {
		return nil, stackerr.Wrap(err)
	}

	conversionTool, err := i.symbolConversionTool(homedir, nil, e)
	if err != nil {
		return nil, stackerr.Wrap(err)
	}

	cmd := exec.Command(conversionTool, i.Path, folderPath)
	if out, err := cmd.CombinedOutput(); err != nil {
		return nil, stackerr.Newf("Symbol conversion failed with:\n%s", string(out))
	}

	filenames, err := readDirNames(folderPath)
	if err != nil {
		return nil, stackerr.Wrap(err)
	}
	return filenames, nil
}
Example #21
0
func (h *functionHooksCmd) functionHooksDelete(e *parsecli.Env, ctx *parsecli.Context) error {
	params, err := readFunctionName(e, h.Function)
	if err != nil {
		return err
	}
	functionsURL, err := url.Parse(path.Join(defaultFunctionsURL, params.FunctionName))
	if err != nil {
		return stackerr.Wrap(err)
	}

	confirmMessage := fmt.Sprintf(
		"Are you sure you want to delete webhook function: %q (y/n): ",
		params.FunctionName,
	)

	var res functionHook
	if !h.interactive || getConfirmation(confirmMessage, e) {
		_, err = e.ParseAPIClient.Put(functionsURL, map[string]interface{}{"__op": "Delete"}, &res)
		if err != nil {
			return stackerr.Wrap(err)
		}
		fmt.Fprintf(e.Out, "Successfully deleted webhook function %q\n", params.FunctionName)
		if res.FunctionName != "" {
			fmt.Fprintf(e.Out, "Function %q defined in Cloud Code will be used henceforth\n", res.FunctionName)
		}
	}

	return nil
}
Example #22
0
func (s *PlanService) update(req *restful.Request, resp *restful.Response, pl *plan.Plan) {
	// TODO (m0sth8): Check permissions

	raw := &plan.Plan{}

	if err := req.ReadEntity(raw); err != nil {
		logrus.Error(stackerr.Wrap(err))
		resp.WriteServiceError(http.StatusBadRequest, services.WrongEntityErr)
		return
	}
	mgr := s.Manager()
	defer mgr.Close()

	raw.Id = pl.Id

	if err := mgr.Plans.Update(raw); err != nil {
		if mgr.IsNotFound(err) {
			resp.WriteErrorString(http.StatusNotFound, "Not found")
			return
		}
		if mgr.IsDup(err) {
			resp.WriteServiceError(
				http.StatusConflict,
				services.DuplicateErr)
			return
		}
		logrus.Error(stackerr.Wrap(err))
		resp.WriteServiceError(http.StatusInternalServerError, services.DbErr)
		return
	}

	resp.WriteHeader(http.StatusOK)
	resp.WriteEntity(raw)
}
Example #23
0
func (s *MeService) info(req *restful.Request, resp *restful.Response) {
	mgr := s.Manager()
	defer mgr.Close()

	u := filters.GetUser(req)

	query := manager.Or(fltr.GetQuery(&manager.ProjectFltr{Owner: u.Id, Member: u.Id}))

	projects, count, err := mgr.Projects.FilterByQuery(query)
	if err != nil {
		logrus.Error(stackerr.Wrap(err))
	} else {
		// TODO (m0sth8): create default project when user on create is triggered.
		// create one default project
		if count == 0 {
			p, err := mgr.Projects.CreateDefault(u.Id)
			if err != nil {
				logrus.Error(stackerr.Wrap(err))
				// It might be possible, that default project is already created
				// So, client should repeat request
				resp.WriteServiceError(http.StatusInternalServerError, services.DbErr)
				return
			} else {
				projects = append(projects, p)
			}
		}
	}

	info := me.Info{
		User:     u,
		Projects: projects,
	}

	resp.WriteEntity(info)
}
Example #24
0
func (d *deployCmd) getPrevDeplInfo(e *parsecli.Env) (*deployInfo, error) {
	prevDeplInfo := &deployInfo{}
	if _, err := e.ParseAPIClient.Get(&url.URL{Path: "deploy"}, prevDeplInfo); err != nil {
		return nil, stackerr.Wrap(err)
	}
	legacy := len(prevDeplInfo.Checksums.Cloud) == 0 &&
		len(prevDeplInfo.Checksums.Public) == 0 &&
		len(prevDeplInfo.Versions.Cloud) == 0 &&
		len(prevDeplInfo.Versions.Public) == 0
	if legacy {
		var res struct {
			ReleaseName  string            `json:"releaseName,omitempty"`
			Description  string            `json:"description,omitempty"`
			ParseVersion string            `json:"parseVersion,omitempty"`
			Checksums    map[string]string `json:"checksums,omitempty"`
			Versions     map[string]string `json:"userFiles,omitempty"`
		}
		if _, err := e.ParseAPIClient.Get(&url.URL{Path: "deploy"}, &res); err != nil {
			return nil, stackerr.Wrap(err)
		}
		prevDeplInfo.ReleaseName = res.ReleaseName
		prevDeplInfo.Description = res.Description
		prevDeplInfo.ParseVersion = res.ParseVersion
		prevDeplInfo.Checksums.Cloud = res.Checksums
		prevDeplInfo.Versions.Cloud = res.Versions
	}
	return prevDeplInfo, nil
}
Example #25
0
func (c *configAPI) GET(w http.ResponseWriter, req *http.Request) error {
	resp := json.NewEncoder(w)
	keys := req.URL.Query()["key"]
	if len(keys) == 0 {
		w.WriteHeader(http.StatusBadRequest)
		return stackerr.Wrap(resp.Encode(struct{ Error string }{"Invalid Key"}))
	}
	type kvPair struct {
		Key   string `json:"key"`
		Value []byte `json:"value"`
		Err   string `json:"error,omitempty"`
	}
	var kvp []kvPair
	for _, key := range keys {
		pair := kvPair{Key: key}
		val, err := c.dmn.confManager.Get(key)
		if err != nil {
			pair.Err = err.Error()
		} else {
			pair.Value = val
		}
		kvp = append(kvp, pair)
	}

	w.WriteHeader(http.StatusOK)
	return stackerr.Wrap(resp.Encode(kvp))
}
Example #26
0
File: mllp.go Project: deoxxa/mllp
func (r Reader) ReadMessage() ([]byte, error) {
	c, err := r.b.ReadByte()
	if err != nil {
		return nil, stackerr.Wrap(err)
	}

	if c != byte(0x0b) {
		return nil, ErrInvalidHeader(stackerr.Newf("invalid header found; expected 0x0b but got %02x", c))
	}

	d, err := r.b.ReadBytes(byte(0x1c))
	if err != nil {
		return nil, stackerr.Wrap(err)
	}

	if len(d) < 2 {
		return nil, ErrInvalidContent(stackerr.Newf("content including boundary should be at least two bytes long; instead was %d", len(d)))
	}

	if d[len(d)-2] != 0x0d {
		return nil, ErrInvalidBoundary(stackerr.Newf("content should end with 0x0d; instead was %02x", d[len(d)-2]))
	}

	t, err := r.b.ReadByte()
	if err != nil {
		return nil, stackerr.Wrap(err)
	}
	if t != byte(0x0d) {
		return nil, ErrInvalidTrailer(stackerr.Newf("invalid trailer found; expected 0x0d but got %02x", t))
	}

	return d[0 : len(d)-2], nil
}
Example #27
0
func (l *login) storeCredentials(e *env, credentials *credentials) error {
	if l.tokenReader != nil {
		// tests should not store credentials
		return nil
	}

	homeDir, err := homedir.Dir()
	if err != nil {
		return stackerr.Wrap(err)
	}
	location := filepath.Join(homeDir, parseNetrc)
	if err := os.MkdirAll(filepath.Dir(location), 0755); err != nil {
		return stackerr.Wrap(err)
	}
	file, err := os.OpenFile(location, os.O_RDONLY|os.O_CREATE, 0600)
	if err != nil {
		return stackerr.Wrap(err)
	}

	content, err := l.updatedNetrcContent(e, file, credentials)

	file, err = os.OpenFile(location, os.O_WRONLY|os.O_TRUNC, 0600)
	_, err = file.Write(content)
	return stackerr.Wrap(err)
}
Example #28
0
func writeLegacyConfigFile(c *legacyConfig, path string) error {
	b, err := json.MarshalIndent(c, "", "  ")
	if err != nil {
		return stackerr.Wrap(err)
	}
	return stackerr.Wrap(ioutil.WriteFile(path, b, 0600))
}
Example #29
0
func (s *ProjectService) update(req *restful.Request, resp *restful.Response, p *project.Project) {
	raw := &ProjectEntity{}

	if err := req.ReadEntity(raw); err != nil {
		logrus.Error(stackerr.Wrap(err))
		resp.WriteServiceError(http.StatusBadRequest, services.WrongEntityErr)
		return
	}

	user := filters.GetUser(req)

	if p.Owner != user.Id {
		resp.WriteServiceError(http.StatusForbidden, services.AuthForbidErr)
		return
	}

	mgr := s.Manager()
	defer mgr.Close()

	if raw.Name != "" {
		p.Name = raw.Name
	}
	if err := mgr.Projects.Update(p); err != nil {
		if mgr.IsDup(err) {
			resp.WriteServiceError(
				http.StatusConflict,
				services.NewError(services.CodeDuplicate, "project with this name and owner is existed"))
			return
		}
		logrus.Error(stackerr.Wrap(err))
		resp.WriteServiceError(http.StatusInternalServerError, services.DbErr)
		return
	}
	resp.WriteEntity(p)
}
Example #30
0
func (h *logsCmd) run(e *parsecli.Env, ctx *parsecli.Context) error {
	hkConfig, ok := ctx.AppConfig.(*parsecli.HerokuAppConfig)
	if !ok {
		return stackerr.New("Unexpected config format")
	}

	opts := &heroku.LogSessionCreateOpts{}
	if h.num == 0 {
		h.num = 50
	}
	//source := "app"
	//opts.Source = &source
	opts.Lines = &h.num
	opts.Tail = &h.tail

	session, err := e.HerokuAPIClient.LogSessionCreate(
		hkConfig.HerokuAppID,
		opts,
	)
	if err != nil {
		return stackerr.Wrap(err)
	}
	resp, err := http.Get(session.LogplexURL)
	if err != nil {
		return stackerr.Wrap(err)
	}
	_, err = io.Copy(e.Out, resp.Body)
	return stackerr.Wrap(err)
}