Ejemplo n.º 1
0
func DownloadLatestRelease(repository string) string {
	client := github.NewClient(nil)
	releases, _, err := client.Repositories.ListReleases("appstax", repository, nil)
	fail.Handle(err)

	if len(releases) == 0 {
		fail.Handle(errors.New("No releases found for '" + repository + "'"))
	}

	latest := releases[0]
	version := *latest.TagName
	log.Debugf("Latest release: %s", version)

	path := dir() + repository + "/" + version + "/"

	if _, err := os.Stat(path); err == nil {
		log.Debugf("Release already downloaded at %s", path)
		return path
	}

	asset, err := getAssetByName(latest, repository+".zip")
	fail.Handle(err)

	err = DownloadAndUnzip(*asset.BrowserDownloadURL, path)
	fail.Handle(err)

	return path
}
Ejemplo n.º 2
0
func ReadSessionID() string {
	sessionID, _ := ioutil.ReadFile(dir() + "/session")
	if len(sessionID) == 0 {
		log.Debugf("Session id is empty")
	} else {
		log.Debugf("Read session id starting with %s", string(sessionID)[0:5]+"...")
	}
	return string(sessionID)
}
Ejemplo n.º 3
0
func createServerDir() {
	dir := config.Read().ServerDir
	if _, err := os.Stat(dir); os.IsNotExist(err) {
		err = os.MkdirAll(dir, 0700)
		fail.Handle(err)
		log.Debugf("Created server directory '%s'", dir)
	} else {
		log.Debugf("Not creating server directory. '%s' already exists.", dir)
	}
}
Ejemplo n.º 4
0
func Put(url string, data interface{}) ([]byte, *http.Response, error) {
	log.Debugf("HTTP PUT: %s", url)
	json, err := json.Marshal(data)
	fail.Handle(err)
	log.Debugf("HTTP PUT JSON: %s", json)
	client := &http.Client{}
	req, err := http.NewRequest("PUT", url, bytes.NewBuffer(json))
	addHeaders(req)
	resp, err := client.Do(req)
	fail.Handle(err)
	return handleResult(resp, err)
}
Ejemplo n.º 5
0
func selectSubdomain(appID string, required bool) {
	app, _ := account.GetAppByID(appID)
	log.Debugf("Subdomain app: %v", app)
	for {
		if required {
			app.HostingSubdomain = term.GetString("Choose a *.appstax.io subdomain for hosting")
		} else {
			term.Println("Choose a *.appstax.io subdomain for hosting:")
			term.Println("(Leave this blank if you wish to decide this later.)")
			app.HostingSubdomain = term.GetString("Subdomain")
		}

		if app.HostingSubdomain != "" {
			err1 := account.SaveApp(app)
			if err1 != nil {
				term.Println(err1.Error())
			}
			err2 := account.AddCorsOrigin(appID, fmt.Sprintf("http://%s.appstax.io", app.HostingSubdomain))
			if err2 != nil {
				term.Println(err2.Error())
			}
			if err1 == nil && err2 == nil {
				term.Printf("Successfully configured %s.appstax.io\n", app.HostingSubdomain)
				return
			}
		} else if !required {
			return
		}
	}
}
Ejemplo n.º 6
0
func DownloadAndUnzip(remoteUrl string, localPath string) error {
	log.Debugf("Downloading %s to %s", remoteUrl, localPath)

	tmp, err := download(remoteUrl)
	if err != nil {
		return err
	}

	log.Debugf("zip temporarily saved: %s", tmp)

	err = unzip(tmp, localPath)
	if err != nil {
		return err
	}

	return nil
}
Ejemplo n.º 7
0
func Get(url string) ([]byte, *http.Response, error) {
	log.Debugf("HTTP GET: %s", url)
	client := &http.Client{}
	req, err := http.NewRequest("GET", url, nil)
	addHeaders(req)
	resp, err := client.Do(req)
	fail.Handle(err)
	return handleResult(resp, err)
}
Ejemplo n.º 8
0
func getAssetByName(release github.RepositoryRelease, name string) (github.ReleaseAsset, error) {
	for _, asset := range release.Assets {
		log.Debugf("Available asset: '%s'", *asset.Name)
		if *asset.Name == name {
			return asset, nil
		}
	}
	return github.ReleaseAsset{}, errors.New("Asset '" + name + "' not found")
}
Ejemplo n.º 9
0
func handleResult(resp *http.Response, err error) ([]byte, *http.Response, error) {
	defer resp.Body.Close()
	body, _ := ioutil.ReadAll(resp.Body)
	log.Debugf("HTTP response (%d): %s", resp.StatusCode, body)
	if err == nil && resp.StatusCode/100 == 2 {
		return body, resp, nil
	} else {
		return nil, nil, errors.New(getErrorMessage(resp, body, err))
	}
}
Ejemplo n.º 10
0
func Write(values map[string]string) {
	config := Read()
	config.AppKey = values["AppKey"]
	config.PublicDir = values["PublicDir"]
	config.ServerDir = values["ServerDir"]
	encoded, err := json.MarshalIndent(config, "", "    ")
	fail.Handle(err)
	ioutil.WriteFile(fileName, encoded, 0644)
	log.Debugf("Wrote config file: %s", encoded)
}
Ejemplo n.º 11
0
func Read() Config {
	var config Config
	dat, err := ioutil.ReadFile(FilePath())
	if err != nil {
		log.Debugf("Could not find appstax.conf")
	} else {
		err = json.Unmarshal(dat, &config)
		fail.Handle(err)
	}
	insertDefaults(&config)
	return config
}
Ejemplo n.º 12
0
func copy(src string, dst string) {
	log.Debugf("Copy '%s' to '%s'", src, dst)
	filepath.Walk(src, func(srcPath string, fileInfo os.FileInfo, err error) error {
		fail.Handle(err)
		if !fileInfo.IsDir() {
			log.Debugf("Copying file from '%s'", srcPath)
			dstPath := filepath.Join(dst, srcPath[len(src):])
			log.Debugf("... to destination '%s'", dstPath)
			srcFile, err := os.Open(srcPath)
			fail.Handle(err)
			defer srcFile.Close()
			os.MkdirAll(filepath.Dir(dstPath), 0755)
			dstFile, err := os.Create(dstPath)
			fail.Handle(err)
			defer dstFile.Close()
			_, err = io.Copy(dstFile, srcFile)
			fail.Handle(err)
		}
		return nil
	})
}
Ejemplo n.º 13
0
func Install(template Template) {
	if template.Repository == "" {
		return
	}

	releasePath := download.DownloadLatestRelease(template.Repository)
	log.Debugf("Downloaded release path: %s", releasePath)

	sourcePath := filepath.Join(releasePath, template.SourcePath)
	copy(sourcePath, config.ResolvePath(template.DestinationPath))
	insertAppKey(template)
}
Ejemplo n.º 14
0
func ShowProgressBar(totalBytes int64) *pb.ProgressBar {
	log.Debugf("Creating progress bar for %d bytes", totalBytes)
	bar := pb.New64(totalBytes)
	bar.SetMaxWidth(70)
	bar.ShowCounters = false
	bar.ShowSpeed = true
	bar.SetUnits(pb.U_BYTES)
	bar.Format("[##-]")
	bar.Prefix("   ")
	bar.Start()
	return bar
}
Ejemplo n.º 15
0
func addAllToArchive(fullRootPath string, tarWriter *tar.Writer) error {
	log.Debugf("Creating archive by walking from root path %s", fullRootPath)
	return filepath.Walk(fullRootPath, func(path string, fileInfo os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if !fileInfo.IsDir() && fileInfo.Name()[:1] != "." {
			err := addFileToArchive(path, path[len(fullRootPath+"/"):], tarWriter, fileInfo)
			if err != nil {
				return err
			}
		}
		return nil
	})
}
Ejemplo n.º 16
0
func PostFile(url string, path string, progressWriter io.Writer) ([]byte, *http.Response, error) {
	log.Debugf("HTTP POST FILE: %s", url)
	file, err := os.Open(path)
	fail.Handle(err)
	defer file.Close()

	fileReader := bufio.NewReader(file)
	teeReader := io.TeeReader(fileReader, progressWriter)

	client := &http.Client{}
	req, err := http.NewRequest("POST", url, teeReader)
	addHeaders(req)

	resp, err := client.Do(req)
	fail.Handle(err)
	return handleResult(resp, err)
}
Ejemplo n.º 17
0
func DoOpen(c *cli.Context) {
	useOptions(c)
	dest := c.Args().First()
	log.Debugf("Open destination: %s", dest)
	url := ""
	message := ""

	switch dest {

	default:
		fallthrough
	case "deployed":
		app, err := account.GetCurrentApp()
		if err != nil {
			message = "Sorry, could not find a deployed app to open."
		}
		url = "http://" + app.HostingSubdomain + ".appstax.io"
		break

	case "admin":
		url = "http://appstax.com/admin/#/dashboard"
		break

	case "local":
		url = "http://localhost:9000/"
		break
	}

	if url != "" {
		term.Printf("Opening %s in your browser.\n", url)
		err := open.Start(url)
		if err != nil {
			message = "Ooops! Something went wrong."
		}
	}

	if message != "" {
		term.Section()
		term.Println(message)
	}
}
Ejemplo n.º 18
0
func WriteAccountID(accountID string) {
	path := dir() + "/account"
	err := ioutil.WriteFile(path, []byte(accountID), 0644)
	fail.Handle(err)
	log.Debugf("Wrote account id to %s", path)
}
Ejemplo n.º 19
0
func WriteUserID(userID string) {
	path := dir() + "/user"
	err := ioutil.WriteFile(path, []byte(userID), 0644)
	fail.Handle(err)
	log.Debugf("Wrote user id to %s", path)
}
Ejemplo n.º 20
0
func WriteSessionID(sessionID string) {
	path := dir() + "/session"
	err := ioutil.WriteFile(path, []byte(sessionID), 0644)
	fail.Handle(err)
	log.Debugf("Wrote session id to %s", path)
}