Ejemplo n.º 1
0
func httpWalk(config *httpTaskConfig, fullPath string, fi os.FileInfo, err error, tp TaskParams) error {
	if err != nil {
		return err
	}
	if fi.IsDir() {
		return nil
	}
	versionDir := filepath.Join(tp.OutDestRoot, tp.Settings.GetFullVersionName())
	relativePath := strings.TrimPrefix(strings.Replace(fullPath, versionDir, "", -1), "/")
	if !tp.Settings.IsQuiet() {
		log.Printf("Considering %s", relativePath)
	}
	resourceGlobs := core.ParseCommaGlobs(config.includePatterns)
	excludeGlobs := core.ParseCommaGlobs(config.excludePatterns)
	matches := false
	for _, resourceGlob := range resourceGlobs {
		ok, err := filepath.Match(resourceGlob, fi.Name())
		if err != nil {
			return err
		}
		if ok {
			matches = true
		}
	}
	if matches == false {
		if !tp.Settings.IsQuiet() {
			log.Printf("Not including %s (for include patterns %s)", relativePath, strings.Join(resourceGlobs, ", "))
		}
		return nil
	}
	for _, excludeGlob := range excludeGlobs {
		ok, err := filepath.Match(excludeGlob, fi.Name())
		if err != nil {
			return err
		}
		if ok {
			if !tp.Settings.IsQuiet() {
				log.Printf("Excluding %s (for exclude pattern %s)", relativePath, excludeGlob)
			}
			return nil
		}
	}
	return httpUploadFile(config, fullPath, fi, tp)
}
Ejemplo n.º 2
0
Archivo: github.go Proyecto: yl10/goxc
func ghWalkFunc(fullPath string, fi2 os.FileInfo, err error, reportFilename string, dirs []string, tp tasks.TaskParams, format string, report tasks.BtReport) error {
	excludeResources := tp.Settings.GetTaskSettingString(tasks.TASK_PUBLISH_GITHUB, "exclude")
	excludeGlobs := core.ParseCommaGlobs(excludeResources)
	versionDir := filepath.Join(tp.OutDestRoot, tp.Settings.GetFullVersionName())
	relativePath := strings.Replace(fullPath, versionDir, "", -1)
	relativePath = strings.TrimPrefix(relativePath, "/")
	//fmt.Printf("relative path %s, full path %s\n", relativePath, fullPath)
	if fi2.IsDir() {
		//check globs ...
		for _, excludeGlob := range excludeGlobs {
			ok, err := filepath.Match(excludeGlob, fi2.Name())
			if err != nil {
				return err
			}
			if ok {
				if tp.Settings.IsVerbose() {
					log.Printf("Excluded: %s (pattern %v)", relativePath, excludeGlob)
				}
				return filepath.SkipDir
			}
		}
		return nil
	}
	if fi2.Name() == reportFilename {
		return nil
	}
	owner := tp.Settings.GetTaskSettingString(tasks.TASK_PUBLISH_GITHUB, "owner")
	user := tp.Settings.GetTaskSettingString(tasks.TASK_PUBLISH_GITHUB, "user")
	if user == "" {
		user = owner
	}
	apikey := tp.Settings.GetTaskSettingString(tasks.TASK_PUBLISH_GITHUB, "apikey")
	repository := tp.Settings.GetTaskSettingString(tasks.TASK_PUBLISH_GITHUB, "repository")
	apiHost := tp.Settings.GetTaskSettingString(tasks.TASK_PUBLISH_GITHUB, "apihost")
	uploadApiHost := "https://uploads.github.com"
	downloadsHost := tp.Settings.GetTaskSettingString(tasks.TASK_PUBLISH_GITHUB, "downloadshost")
	includeResources := tp.Settings.GetTaskSettingString(tasks.TASK_PUBLISH_GITHUB, "include")

	resourceGlobs := core.ParseCommaGlobs(includeResources)
	//log.Printf("IncludeGlobs: %v", resourceGlobs)
	//log.Printf("ExcludeGlobs: %v", excludeGlobs)
	matches := false
	for _, resourceGlob := range resourceGlobs {
		ok, err := filepath.Match(resourceGlob, fi2.Name())
		if err != nil {
			return err
		}
		if ok {
			matches = true
		}
	}
	if matches == false {
		if tp.Settings.IsVerbose() {
			log.Printf("Not included: %s (pattern %v)", relativePath, includeResources)
		}
		return nil
	}
	for _, excludeGlob := range excludeGlobs {
		ok, err := filepath.Match(excludeGlob, fi2.Name())
		if err != nil {
			return err
		}
		if ok {
			if tp.Settings.IsVerbose() {
				log.Printf("Excluded: %s (pattern %v)", relativePath, excludeGlob)
			}
			return nil
		}
	}
	first := true

	parent := filepath.Dir(relativePath)
	//platform := strings.Replace(parent, "_", "/", -1)
	//fmt.Fprintf(f, "\n * **%s**:", platform)
	for _, d := range dirs {
		if d == parent {
			first = false
		}
	}
	if first {
		dirs = append(dirs, parent)
	}
	//fmt.Printf("relative path %s, platform %s\n", relativePath, parent)
	text := fi2.Name()
	version := tp.Settings.GetFullVersionName()
	isVerbose := tp.Settings.IsVerbose()
	isQuiet := tp.Settings.IsQuiet()
	contentType := httpc.GetContentType(text)

	prefix := tp.Settings.GetTaskSettingString(tasks.TASK_TAG, "prefix")
	tagName := prefix + version
	release, err := ghGetReleaseForTag(apiHost, owner, apikey, repository, tagName, isVerbose)
	if err != nil {
		return err
	}
	err = ghDoUpload(uploadApiHost, apikey, owner, repository, release, relativePath, fullPath, contentType, isVerbose, isQuiet)
	if err != nil {
		return err
	}
	if first {
		first = false
	} else {
		//commaIfRequired = ","
	}
	if format == "markdown" {
		text = strings.Replace(text, "_", "\\_", -1)
	}
	category := tasks.GetCategory(relativePath)
	downloadsUrl := downloadsHost + "/" + owner + "/" + repository + "/releases/download/" + version + "/" + relativePath + ""
	download := tasks.BtDownload{Text: text, RelativeLink: downloadsUrl}
	v, ok := report.Categories[category]
	var existing []tasks.BtDownload
	if !ok {
		existing = []tasks.BtDownload{}
	} else {
		existing = *v
	}
	existing = append(existing, download)
	report.Categories[category] = &existing

	return err
}
Ejemplo n.º 3
0
Archivo: tasks.go Proyecto: yl10/goxc
// run all given tasks
func RunTasks(workingDirectory string, destPlatforms []platforms.Platform, settings *config.Settings, maxProcessors int) error {
	if settings.IsVerbose() {
		log.Printf("Using Go root: %s", settings.GoRoot)
		log.Printf("looping through each platform")
	}
	appName := core.GetAppName(settings.AppName, workingDirectory)

	outDestRoot, err := core.GetOutDestRoot(appName, workingDirectory, settings.ArtifactsDest)
	if err != nil {
		return err
	}
	defer log.SetPrefix("[goxc] ")
	exclusions := ResolveAliases(settings.TasksExclude)
	appends := ResolveAliases(settings.TasksAppend)
	mains := ResolveAliases(settings.Tasks)
	all := ResolveAliases(settings.TasksPrepend)
	//log.Printf("prepending %v", all)
	all = append(all, mains...)
	all = append(all, appends...)

	//exclude by resolved task names (not by aliases)
	tasksToRun := []string{}
	for _, taskName := range all {
		if !core.ContainsString(exclusions, taskName) {
			tasksToRun = append(tasksToRun, taskName)
		}
	}
	//0.6 check all tasks are valid before continuing
	for _, taskName := range tasksToRun {
		if _, keyExists := allTasks[taskName]; !keyExists {
			if strings.HasPrefix(taskName, ".") {
				log.Printf("'%s' looks like a directory, not a task - specify 'working directory' with -wd option", taskName)
			}
			if e, _ := core.FileExists(taskName); e {
				log.Printf("'%s' looks like a directory, not a task - specify 'working directory' with -wd option", taskName)
			}
			if settings.IsVerbose() {
				log.Printf("Task '%s' does NOT exist!", taskName)
			}
			return errors.New("Task '" + taskName + "' does not exist")
		}
	}
	mainDirs := []string{}
	allPackages := []string{}
	if len(tasksToRun) == 1 && tasksToRun[0] == "toolchain" {
		log.Printf("Toolchain task only - not searching for main dirs")
		//mainDirs = []string{workingDirectory}
	} else {
		var err error
		excludes := core.ParseCommaGlobs(settings.MainDirsExclude)
		excludesSource := core.ParseCommaGlobs(settings.SourceDirsExclude)
		excludesSource = append(excludesSource, excludes...)
		allPackages, err = source.FindSourceDirs(workingDirectory, "", excludesSource, settings.IsVerbose())
		if err != nil || len(allPackages) == 0 {
			log.Printf("Warning: could not establish list of source packages. Using working directory")
			allPackages = []string{workingDirectory}
		}
		mainDirs, err = source.FindMainDirs(workingDirectory, excludes, settings.IsVerbose())
		if err != nil || len(mainDirs) == 0 {
			log.Printf("Warning: could not find any main dirs: %v", err)
		} else {
			if settings.IsVerbose() {
				log.Printf("Found 'main package' dirs (len %d): %v", len(mainDirs), mainDirs)
			}
		}
	}
	if settings.IsVerbose() {
		log.Printf("Running tasks: %v", tasksToRun)
		log.Printf("All packages: %v", allPackages)
	}
	for _, taskName := range tasksToRun {
		log.SetPrefix("[goxc:" + taskName + "] ")
		if settings.IsVerbose() {
			log.Printf("Running task %s with settings: %v", taskName, settings.TaskSettings[taskName])
		}
		err := runTask(taskName, destPlatforms, allPackages, mainDirs, appName, workingDirectory, outDestRoot, settings, maxProcessors)
		if err != nil {
			// TODO: implement 'force' option.
			log.Printf("Stopping after '%s' failed with error '%v'", taskName, err)
			return err
		} else {
			if !settings.IsQuiet() {
				log.Printf("Task %s succeeded", taskName)
			}
		}
	}
	return nil
}
Ejemplo n.º 4
0
Archivo: bintray.go Proyecto: yl10/goxc
func walkFunc(fullPath string, fi2 os.FileInfo, err error, reportFilename string, dirs []string, tp TaskParams, format string, report BtReport) error {
	if fi2.IsDir() || fi2.Name() == reportFilename {

		return nil
	}
	subject := tp.Settings.GetTaskSettingString(TASK_BINTRAY, "subject")
	user := tp.Settings.GetTaskSettingString(TASK_BINTRAY, "user")
	if user == "" {
		user = subject
	}
	apikey := tp.Settings.GetTaskSettingString(TASK_BINTRAY, "apikey")
	repository := tp.Settings.GetTaskSettingString(TASK_BINTRAY, "repository")
	pkg := tp.Settings.GetTaskSettingString(TASK_BINTRAY, "package")
	apiHost := tp.Settings.GetTaskSettingString(TASK_BINTRAY, "apihost")
	downloadsHost := tp.Settings.GetTaskSettingString(TASK_BINTRAY, "downloadshost")
	includeResources := tp.Settings.GetTaskSettingString(TASK_BINTRAY, "include")
	excludeResources := tp.Settings.GetTaskSettingString(TASK_BINTRAY, "exclude")
	versionDir := filepath.Join(tp.OutDestRoot, tp.Settings.GetFullVersionName())

	relativePath := strings.Replace(fullPath, versionDir, "", -1)
	relativePath = strings.TrimPrefix(relativePath, "/")
	fmt.Printf("relative path %s, full path %s\n", relativePath, fullPath)

	resourceGlobs := core.ParseCommaGlobs(includeResources)
	//log.Printf("IncludeGlobs: %v", resourceGlobs)
	excludeGlobs := core.ParseCommaGlobs(excludeResources)
	//log.Printf("ExcludeGlobs: %v", excludeGlobs)
	matches := false
	for _, resourceGlob := range resourceGlobs {
		ok, err := filepath.Match(resourceGlob, fi2.Name())
		if err != nil {
			return err
		}
		if ok {
			matches = true
		}
	}
	if matches == false {
		if !tp.Settings.IsQuiet() {
			log.Printf("Not included: %s (pattern %v)", relativePath, includeResources)
		}
		return nil
	}
	for _, excludeGlob := range excludeGlobs {
		ok, err := filepath.Match(excludeGlob, fi2.Name())
		if err != nil {
			return err
		}
		if ok {
			if !tp.Settings.IsQuiet() {
				log.Printf("Excluded: %s (pattern %v)", relativePath, excludeGlob)
			}
			return nil
		}
	}
	first := true

	parent := filepath.Dir(relativePath)
	//platform := strings.Replace(parent, "_", "/", -1)
	//fmt.Fprintf(f, "\n * **%s**:", platform)
	for _, d := range dirs {
		if d == parent {
			first = false
		}
	}
	if first {
		dirs = append(dirs, parent)
	}
	//fmt.Printf("relative path %s, platform %s\n", relativePath, parent)
	text := fi2.Name()
	/*
		text := strings.Replace(fi2.Name(), "_", "\\_", -1)
		if strings.HasSuffix(fi2.Name(), ".zip") {
			text = "zip"
		} else if strings.HasSuffix(fi2.Name(), ".deb") {
			text = "deb"
		} else if strings.HasSuffix(fi2.Name(), ".tar.gz") {
			text = "tar.gz"
		} else if fi2.Name() == tp.AppName || fi2.Name() == tp.AppName+".exe" {
			text = "executable"
		}
	*/
	//PUT /content/:subject/:repo/:package/:version/:path
	url := apiHost + "/content/" + subject + "/" + repository + "/" + pkg + "/" + tp.Settings.GetFullVersionName() + "/" + relativePath
	// for some reason there's no /pkg/ level in the downloads url.
	downloadsUrl := downloadsHost + "/content/" + subject + "/" + repository + "/" + relativePath + "?direct"
	contentType := httpc.GetContentType(text)
	resp, err := httpc.UploadFile("PUT", url, subject, user, apikey, fullPath, relativePath, contentType, !tp.Settings.IsQuiet())
	if err != nil {
		if serr, ok := err.(httpc.HttpError); ok {
			if serr.StatusCode == 409 {
				//conflict. skip
				//continue but dont publish.
				//TODO - provide an option to replace existing artifact
				//TODO - ?check exists before attempting upload?
				log.Printf("WARNING - file already exists. Skipping. %v", resp)
				return nil
			} else {
				return err
			}
		} else {
			return err
		}
	}
	if !tp.Settings.IsQuiet() {
		log.Printf("File uploaded. (expected empty map[]): %v", resp)
	}
	//commaIfRequired := ""
	if first {
		first = false
	} else {
		//commaIfRequired = ","
	}
	if format == "markdown" {
		text = strings.Replace(text, "_", "\\_", -1)
	}
	category := GetCategory(relativePath)
	download := BtDownload{text, downloadsUrl}
	v, ok := report.Categories[category]
	var existing []BtDownload
	if !ok {
		existing = []BtDownload{}
	} else {
		existing = *v
	}
	existing = append(existing, download)
	report.Categories[category] = &existing

	//_, err = fmt.Fprintf(f, "%s [[%s](%s)]", commaIfRequired, text, downloadsUrl)
	if err != nil {
		return err
	}
	err = publish(apiHost, user, apikey, subject, repository, pkg, tp.Settings.GetFullVersionName(), !tp.Settings.IsQuiet())
	return err
}