Cache fix (#54)

* Some debug log

* new user input: verbose_log

* Using warning instead of error if there is any error during the Cachefile check/compare.

* add more debug log

* add `Cartfile.resolved` to the `BITRISE_CACHE_INCLUDE_PATHS` env, so the `Cache push` step will push it automatically. With that, the user does not need to do it manually 🎉

* update readme: removed the  `./Carthage -> ./Carthage/Cachefile` step, because it will be handled by the `Carthage` step itself.

* clean

* Revert "add `Cartfile.resolved` to the `BITRISE_CACHE_INCLUDE_PATHS` env, so the `Cache push` step will push it automatically. With that, the user does not need to do it manually 🎉"

This reverts commit b08d51b.

* Update warnings about cache process

* temporary branch change for the sample app to test the cache mechanism on CI

* Revert "temporary branch change for the sample app to test the cache mechanism on CI"

This reverts commit 0f74976.

* PR clean - fix

* clean + path fix

* PR: log ifxes

* dep -update github.com/bitrise-io/go-steputils

Author: BirmacherAkos

Gopkg.lock

@@ -8,7 +8,7 @@
 
 [[constraint]]
   branch = "master"
-  name = "github.com/bitrise-tools/go-steputils"
+  name = "github.com/bitrise-io/go-steputils"
 
 [[constraint]]
   branch = "master"

Gopkg.toml

@@ -6,8 +6,8 @@ Plain simple build step for setting up your project with [Carthage](https://gith
 
 You can cache the result of `carthage bootstrap` to make Bitrise faster when building unchanged dependencies. For that you'll have to [set up caching](http://devcenter.bitrise.io/caching/about-caching/) in your Bitrise workflow.
 
-1. add a cache pull step before your Carthage step,
-2. set up a cache push step after your Carthage step and make sure to add `./Carthage -> ./Carthage/Cachefile`.
+1. add a `Cache pull` step **before** your `Carthage` step,
+2. add a `Cache push` step **after** your `Carthage` step,
 
 The `Cachefile` stores a Swift version you ran `carthage bootstrap` the last time and the content of your `Cartfile.resolved`. Until either of these information is not changed between builds, Bitrise will ignore the `bootstrap` call and use the cached content of your `Carthage/Build` directory for building your project. If you have changes in your `Cartfile.resolved`, or changed the stack to one with a different Swift version, it will run `carthage bootstrap` to make sure the cache is only used when it's 100% compatible.
 

README.md

@@ -3,16 +3,17 @@ package main
 // ConfigsModel ...
 import (
 	"fmt"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strings"
 
+	"github.com/bitrise-io/go-steputils/cache"
+	"github.com/bitrise-io/go-steputils/stepconf"
 	"github.com/bitrise-io/go-utils/command"
 	"github.com/bitrise-io/go-utils/fileutil"
 	"github.com/bitrise-io/go-utils/log"
 	"github.com/bitrise-io/go-utils/pathutil"
-	"github.com/bitrise-tools/go-steputils/cache"
-	"github.com/bitrise-tools/go-steputils/stepconf"
 	version "github.com/hashicorp/go-version"
 	"github.com/kballard/go-shellquote"
 )
@@ -32,6 +33,9 @@ type Config struct {
 	CarthageCommand   string          `env:"carthage_command,required"`
 	CarthageOptions   string          `env:"carthage_options"`
 	SourceDir         string          `env:"BITRISE_SOURCE_DIR"`
+
+	// Debug
+	VerboseLog bool `env:"verbose_log,opt[yes,no]"`
 }
 
 func fail(format string, v ...interface{}) {
@@ -66,63 +70,119 @@ func contentOfFile(pth string) (string, error) {
 	if exist, err := pathutil.IsPathExists(pth); err != nil {
 		return "", err
 	} else if !exist {
-		return "", nil
+		return "", fmt.Errorf("file not exists: %s", pth)
 	}
 
 	return fileutil.ReadStringFromFile(pth)
 }
 
-func isDirEmpty(dirPth string) (bool, error) {
-	if exist, err := pathutil.IsDirExists(dirPth); err != nil {
-		return false, err
-	} else if !exist {
-		return false, nil
-	}
-
-	pattern := filepath.Join(dirPth, "*")
-	files, err := filepath.Glob(pattern)
-	if err != nil {
-		return false, err
-	}
-
-	return (len(files) == 0), nil
-}
-
 func isCacheAvailable(srcDir string, swiftVersion string) (bool, error) {
+	log.Printf("Check cache specific files")
+	buildDirAvailable, cacheFileAvailable, resolvedFileAvailable := true, true, true
+
 	// check for built dependencies (Carthage/Build/*)
+	fmt.Print("- Carthage/Build directory: ")
 	carthageDir := filepath.Join(srcDir, carthageDirName)
 	carthageBuildDir := filepath.Join(carthageDir, buildDirName)
-	if empty, err := isDirEmpty(carthageBuildDir); err != nil {
-		return false, err
-	} else if empty {
-		return false, nil
+
+	files, err := ioutil.ReadDir(carthageBuildDir)
+	if err != nil {
+		buildDirAvailable = false
+		log.Errorf("not found")
+	} else if len(files) == 0 {
+		buildDirAvailable = false
+		log.Errorf("empty")
+	} else {
+		log.Successf("found")
 	}
+
 	// ---
 
 	// read cache indicator file (Carthage/Cachefile)
+	fmt.Print("- Cachfile: ")
+	var cacheFileContent string
+
 	cacheFilePth := filepath.Join(carthageDir, cacheFileName)
-	cacheFileContent, err := contentOfFile(cacheFilePth)
-	if err != nil {
+	if exist, err := pathutil.IsPathExists(cacheFilePth); err != nil {
 		return false, err
+	} else if !exist {
+		cacheFileAvailable = false
+		log.Errorf("not available yet")
+	} else {
+		log.Successf("found")
+		log.Debugf(cacheFileName + " exists in " + cacheFilePth + "\n")
+
+		cacheFileContent, err = contentOfFile(cacheFilePth)
+		if err != nil {
+			return false, err
+		} else if cacheFileContent == "" {
+			log.Errorf("Cachfile is empty")
+		} else {
+			log.Debugf(cacheFileName + " content: " + cacheFileContent + "\n")
+		}
 	}
-	if cacheFileContent == "" {
-		return false, nil
-	}
+
 	// --
 
 	// read Cartfile.resolved
+	fmt.Print("- Cartfile.resolved: ")
+	var resolvedFileContent string
+
 	resolvedFilePath := filepath.Join(srcDir, resolvedFileName)
-	resolvedFileContent, err := contentOfFile(resolvedFilePath)
-	if err != nil {
+	if exist, err := pathutil.IsPathExists(resolvedFileName); err != nil {
 		return false, err
+	} else if !exist {
+		log.Errorf("not found")
+		resolvedFileAvailable = false
+	} else {
+		log.Successf("found")
+
+		resolvedFileContent, err = contentOfFile(resolvedFilePath)
+		if err != nil {
+			return false, err
+
+		} else if resolvedFileContent == "" {
+			return false, fmt.Errorf("Catfile.resolved is empty")
+		}
+		log.Debugf(resolvedFileName + " content: " + resolvedFileContent + "\n")
 	}
-	if resolvedFileContent == "" {
-		return false, nil
-	}
+
 	// ---
 
-	desiredCacheContent := fmt.Sprintf("--Swift version: %s --Swift version \n --%s: %s --%s", swiftVersion, resolvedFileName, resolvedFileContent, resolvedFileName)
-	return cacheFileContent == desiredCacheContent, nil
+	// Warn messages about the missing files
+
+	// Print the warning about the missing Cachefile only if the other required file (Cartfile.resolved) is available.
+	// If the Cartfile.resolved is not found, then we don't want to mislead the user with this warning.
+	if !cacheFileAvailable && resolvedFileAvailable {
+		fmt.Println()
+		log.Warnf("The " + cacheFileName + " is generated by the step. Probably cache not initialised yet (first cache push initialises the cache), nothing to worry about ;)")
+
+	}
+
+	if !resolvedFileAvailable {
+		fmt.Println()
+		log.Warnf("No "+resolvedFileName+" found at: %s", resolvedFilePath)
+		log.Warnf("Make sure it's committed into your repository!")
+		log.Warnf(resolvedFileName + " presence ensures that Bitrise will use exactly the same versions of dependencies as you in your local environment. ")
+		log.Warnf("The dependencies will not be cached until the " + resolvedFileName + " file presents in the repository.")
+	}
+
+	if buildDirAvailable && cacheFileAvailable && resolvedFileAvailable {
+		desiredCacheContent := fmt.Sprintf("--Swift version: %s --Swift version \n --%s: %s --%s", swiftVersion, resolvedFileName, resolvedFileContent, resolvedFileName)
+		if cacheFileContent != desiredCacheContent {
+			log.Debugf(
+				"Cachefile is not valid.\n" +
+					"Desired cache content:\n" +
+					desiredCacheContent +
+					"CacheFile content:\n" +
+					cacheFileContent,
+			)
+
+			return false, nil
+		}
+	}
+
+	return (buildDirAvailable && cacheFileAvailable && resolvedFileAvailable), nil
 }
 
 func collectCarthageCache(projectDir string) error {
@@ -153,6 +213,8 @@ func main() {
 	}
 	stepconf.Print(configs)
 
+	log.SetEnableDebugLog(configs.VerboseLog)
+
 	// Environment
 	fmt.Println()
 	log.Infof("Environment:")
@@ -167,7 +229,7 @@ func main() {
 	if err != nil {
 		fail("Failed to get swift version, error: %s", err)
 	}
-	log.Printf("- SwiftVersion: %s", strings.Replace(swiftVersion, "\n", " - ", -1))
+	log.Printf("- SwiftVersion: %s", strings.Replace(swiftVersion, "\n", "- ", -1))
 	// --
 
 	// Parse options
@@ -208,10 +270,14 @@ func main() {
 
 		cacheAvailable, err := isCacheAvailable(projectDir, swiftVersion)
 		if err != nil {
-			fail("Failed to check if cached is available, error: %s", err)
+			log.Warnf("Failed to check if cached is available, error: %s", err)
 		}
 
-		log.Printf("cache available: %v", cacheAvailable)
+		if cacheAvailable {
+			log.Successf("Cache available")
+		} else {
+			log.Errorf("Cache not available")
+		}
 
 		if cacheAvailable {
 			if err := collectCarthageCache(projectDir); err != nil {

main.go

@@ -60,3 +60,12 @@ inputs:
 
         __UNCHECK EVERY SCOPE BOX__ when creating this token. There is no reason this token needs access to private information.
       is_sensitive: true
+  - verbose_log: "no"
+    opts:
+      category: Debug
+      title: "Enable verbose logging?"
+      description: Enable verbose logging?
+      is_required: true
+      value_options:
+      - "yes"
+      - "no"