On the way to process directories via grpc

configs/firecracker.go

@@ -48,7 +48,7 @@ func NewFcConfigProvider(jailingFcConfig *JailingFirecrackerConfig, machineConfi
 
 func (c *defaultFcConfigProvider) ToSDKConfig() firecracker.Config {
 
-	var fifo io.WriteCloser // TODO: do it like firectl does it
+	var fifo io.WriteCloser // CONSIDER: do it like firectl does it
 
 	return firecracker.Config{
 		SocketPath:      "",      // given via Jailer

go.mod

@@ -10,6 +10,7 @@ require (
 	github.com/firecracker-microvm/firecracker-go-sdk v0.22.0
 	github.com/go-git/go-git/v5 v5.2.0
 	github.com/gofrs/uuid v4.0.0+incompatible
+	github.com/golang/protobuf v1.5.1
 	github.com/hashicorp/go-hclog v0.15.0
 	github.com/hashicorp/go-multierror v1.0.0
 	github.com/mitchellh/mapstructure v1.3.2

pkg/build/dependency.go

@@ -51,9 +51,9 @@ func (ddb *defaultDependencyBuild) Build(externalCopies []commands.Copy) ([]reso
 		return emptyResponse, fmt.Errorf("error fetching Docker client: %+v", clientErr)
 	}
 
-	// TODO: verify that this is actually possible with Docker.
 	// Do not return early, maybe somebody attempts to build a base image
 	// using the multistage build but without extracting actual resources.
+	// This is perfectly possible with Docker.
 
 	// The cloned sources reside in .../sources directory, let's write our stage Dockerfile in there
 	randFileName := strings.ToLower(utils.RandStringBytes(32))

pkg/build/resources/resource.go

@@ -191,16 +191,11 @@ func (dr *defaultResolver) resolveResources(originalSource, resourcePath, target
 			return nil, fmt.Errorf("resource failed: resolved '%s', reason: %v", match, statErr)
 		}
 		if statResult.IsDir() {
-			resources = append(resources, &defaultResolvedResource{contentsReader: func() (io.ReadCloser, error) {
-				return ioutil.NopCloser(bytes.NewReader([]byte{})), nil
-			},
-				isDir:         true,
-				resolved:      newPath,
-				sourcePath:    resourcePath,
-				targetMode:    statResult.Mode().Perm(),
-				targetPath:    targetPath,
-				targetWorkdir: targetWorkdir,
-				targetUser:    targetUser})
+			resources = append(resources,
+				NewResolvedDirectoryResourceWithPath(statResult.Mode().Perm(),
+					newPath, resourcePath, targetPath,
+					targetWorkdir,
+					targetUser))
 		} else {
 			resources = append(resources, &defaultResolvedResource{contentsReader: func() (io.ReadCloser, error) {
 				file, err := os.Open(newPath)
@@ -238,3 +233,17 @@ func NewResolvedFileResourceWithPath(contentsReader func() (io.ReadCloser, error
 		targetWorkdir: workdir,
 		targetUser:    user}
 }
+
+// NewResolvedDirectoryResourceWithPath creates a resolved resource from input information containing resource source path.
+func NewResolvedDirectoryResourceWithPath(mode fs.FileMode, resolvedPath, sourcePath, targetPath string, workdir commands.Workdir, user commands.User) ResolvedResource {
+	return &defaultResolvedResource{contentsReader: func() (io.ReadCloser, error) {
+		return ioutil.NopCloser(bytes.NewReader([]byte{})), nil
+	},
+		isDir:         true,
+		resolved:      resolvedPath,
+		targetMode:    mode,
+		sourcePath:    sourcePath,
+		targetPath:    targetPath,
+		targetWorkdir: workdir,
+		targetUser:    user}
+}

pkg/build/rootfs.go

@@ -159,7 +159,7 @@ func (b *defaultBuild) CreateContext(dependencies server.Resources) (*server.Wor
 						ctx.ResourcesResolved[sourcePath] = []resources.ResolvedResource{dependencyResource}
 
 						ctx.ExecutableCommands = append(ctx.ExecutableCommands, commands.Copy{
-							OriginalCommand:    "",
+							OriginalCommand:    tcommand.OriginalCommand,
 							OriginalSource:     dependencyResource.ResolvedURIOrPath(),
 							Source:             sourcePath,
 							Target:             dependencyResource.TargetPath(),