mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-17 07:08:01 +08:00
- Reuse existing content-addressed shadow binaries in `<plugin_dir>/.shadow` (with a per-directory shared cache fallback) and verify target digests before creating any temporary files. - Publish shadow binaries without unlinking active targets and coordinate plugin loading with stale shadow cleanup via OS-level file locks. - Add regression tests covering cross-restart shadow reuse, zero-write cache hits, fallback isolation, and concurrent load/prune coordination. Closes: #7323
606 lines
17 KiB
Go
606 lines
17 KiB
Go
//go:build windows || (cgo && (linux || darwin || freebsd))
|
|
|
|
package pluginhost
|
|
|
|
import (
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
// Plugin dynamic libraries are loaded from content-addressed shadow copies.
|
|
// A loaded Go plugin image must stay mapped for the lifetime of the host
|
|
// process (its runtime cannot be unloaded), so loading from a shadow copy
|
|
// keeps the original artifact replaceable and gives every distinct plugin
|
|
// build its own path, which dynamic loaders map as a fresh image.
|
|
|
|
const (
|
|
shadowPluginPrefix = "cliproxy-plugin-"
|
|
shadowPluginTempPrefix = ".cliproxy-plugin-"
|
|
shadowPluginProcessDirPrefix = "pid-"
|
|
shadowPluginCacheDirName = "cache"
|
|
shadowPluginLocalDirName = ".shadow"
|
|
shadowPluginDigestLength = 32
|
|
)
|
|
|
|
type cachedPluginDigest struct {
|
|
size int64
|
|
modTimeNano int64
|
|
digest string
|
|
}
|
|
|
|
var (
|
|
shadowPluginCleanupOnce sync.Once
|
|
cleanedShadowTempDirs sync.Map
|
|
pluginDigestCache sync.Map
|
|
pruneShadowBeforeLockHook func(shadowFileName string)
|
|
)
|
|
|
|
func shadowCopyPlugin(file pluginFile) (string, error) {
|
|
path, release, errShadow := shadowCopyPluginInternal(file, false)
|
|
if release != nil {
|
|
release()
|
|
}
|
|
return path, errShadow
|
|
}
|
|
|
|
func acquireShadowPluginLoad(file pluginFile) (string, func(), error) {
|
|
return shadowCopyPluginInternal(file, true)
|
|
}
|
|
|
|
func acquireShadowPluginFallbackLoad(file pluginFile, failedLoadPath string) (string, func(), error) {
|
|
source := filepath.Clean(file.Path)
|
|
dir, errDir := shadowPluginFallbackDir(source)
|
|
if errDir != nil {
|
|
return "", nil, errDir
|
|
}
|
|
if failedLoadPath != "" && filepath.Clean(filepath.Dir(failedLoadPath)) == filepath.Clean(dir) {
|
|
return "", nil, fmt.Errorf("shadow plugin already in fallback directory")
|
|
}
|
|
size, digest, errHash := cachedOrHashPluginFile(source)
|
|
if errHash != nil {
|
|
return "", nil, errHash
|
|
}
|
|
cleanupShadowTempFilesOnce(dir)
|
|
return shadowCopyPluginToDirWithGuard(file, source, dir, size, digest, true)
|
|
}
|
|
|
|
func shadowCopyPluginInternal(file pluginFile, holdGuard bool) (string, func(), error) {
|
|
shadowPluginCleanupOnce.Do(func() {
|
|
removeStaleShadowPluginDirs(shadowPluginBaseDir(), os.Getpid())
|
|
})
|
|
source := filepath.Clean(file.Path)
|
|
size, digest, errHash := hashPluginFile(source)
|
|
if errHash != nil {
|
|
return "", nil, errHash
|
|
}
|
|
if localDir, errLocalDir := shadowPluginLocalDir(source); errLocalDir == nil {
|
|
cleanupShadowTempFilesOnce(localDir)
|
|
if target, release, errCopy := shadowCopyPluginToDirWithGuard(file, source, localDir, size, digest, holdGuard); errCopy == nil {
|
|
return target, release, nil
|
|
}
|
|
}
|
|
dir, errDir := shadowPluginFallbackDir(source)
|
|
if errDir != nil {
|
|
return "", nil, errDir
|
|
}
|
|
cleanupShadowTempFilesOnce(dir)
|
|
return shadowCopyPluginToDirWithGuard(file, source, dir, size, digest, holdGuard)
|
|
}
|
|
|
|
func cleanupShadowTempFilesOnce(dir string) {
|
|
cleaned := filepath.Clean(dir)
|
|
if _, loaded := cleanedShadowTempDirs.LoadOrStore(cleaned, struct{}{}); loaded {
|
|
return
|
|
}
|
|
removeStaleShadowTempFiles(cleaned)
|
|
}
|
|
|
|
// removeStaleShadowPluginDirs removes shadow directories left behind by
|
|
// host processes that already exited. Directories whose owner process is
|
|
// still alive are kept, because that process may reuse the resident plugin
|
|
// images inside them.
|
|
func removeStaleShadowPluginDirs(baseDir string, currentPID int) {
|
|
entries, errRead := os.ReadDir(baseDir)
|
|
if errRead != nil {
|
|
return
|
|
}
|
|
for _, entry := range entries {
|
|
if entry == nil || !entry.IsDir() {
|
|
continue
|
|
}
|
|
name := entry.Name()
|
|
if !strings.HasPrefix(name, shadowPluginProcessDirPrefix) {
|
|
continue
|
|
}
|
|
pid, errParse := strconv.Atoi(strings.TrimPrefix(name, shadowPluginProcessDirPrefix))
|
|
if errParse != nil || pid <= 0 || pid == currentPID {
|
|
continue
|
|
}
|
|
if shadowPluginProcessAlive(pid) {
|
|
continue
|
|
}
|
|
removeShadowPluginDir(filepath.Join(baseDir, name))
|
|
}
|
|
}
|
|
|
|
func shadowCopyPluginToDir(file pluginFile, dir string) (string, error) {
|
|
source := filepath.Clean(file.Path)
|
|
size, digest, errHash := hashPluginFile(source)
|
|
if errHash != nil {
|
|
return "", errHash
|
|
}
|
|
return shadowCopyPluginToDirWithDigest(file, dir, size, digest)
|
|
}
|
|
|
|
func shadowCopyPluginToDirWithGuard(file pluginFile, sourcePath string, dir string, size int64, digest string, holdGuard bool) (string, func(), error) {
|
|
releaseGuard := func() {}
|
|
if holdGuard {
|
|
sourceDir := filepath.Dir(filepath.Clean(sourcePath))
|
|
unlockCoord, errLock := acquireShadowCoordLock(sourceDir, dir, false, false)
|
|
if errLock != nil {
|
|
return "", nil, errLock
|
|
}
|
|
releaseGuard = unlockCoord
|
|
}
|
|
target, errCopy := shadowCopyPluginToDirWithDigest(file, dir, size, digest)
|
|
if errCopy != nil {
|
|
releaseGuard()
|
|
return "", nil, errCopy
|
|
}
|
|
return target, releaseGuard, nil
|
|
}
|
|
|
|
func acquireShadowCoordLock(sourceDir string, fallbackDir string, exclusive bool, nonBlocking bool) (func(), error) {
|
|
baseDir := fallbackDir
|
|
if strings.TrimSpace(sourceDir) != "" {
|
|
baseDir = filepath.Join(shadowPluginBaseDir(), shadowPluginCacheDirName, shadowDirectoryDigest(sourceDir))
|
|
}
|
|
if errMkdir := os.MkdirAll(baseDir, 0o700); errMkdir != nil {
|
|
return nil, errMkdir
|
|
}
|
|
lockPath := filepath.Join(baseDir, ".cliproxy-coord.lock")
|
|
lockFile, errOpen := os.OpenFile(lockPath, os.O_CREATE|os.O_RDWR, 0o600)
|
|
if errOpen != nil {
|
|
return nil, errOpen
|
|
}
|
|
if errLock := lockShadowCoordFile(lockFile, exclusive, nonBlocking); errLock != nil {
|
|
if errClose := lockFile.Close(); errClose != nil {
|
|
log.WithError(errClose).Debug("pluginhost: coord lock file close failed")
|
|
}
|
|
return nil, errLock
|
|
}
|
|
var once sync.Once
|
|
return func() {
|
|
once.Do(func() {
|
|
unlockShadowCoordFile(lockFile)
|
|
if errClose := lockFile.Close(); errClose != nil {
|
|
log.WithError(errClose).Debug("pluginhost: coord lock file close failed")
|
|
}
|
|
})
|
|
}, nil
|
|
}
|
|
|
|
func shadowCopyPluginToDirWithDigest(file pluginFile, dir string, size int64, digest string) (string, error) {
|
|
source := filepath.Clean(file.Path)
|
|
ext := filepath.Ext(source)
|
|
target := shadowPluginPath(dir, file.ID, digest, ext)
|
|
if shadowPluginMatches(target, size, digest) {
|
|
return target, nil
|
|
}
|
|
|
|
tmp, errTemp := os.CreateTemp(dir, shadowPluginTempPattern(os.Getpid(), file.ID, ext))
|
|
if errTemp != nil {
|
|
return "", errTemp
|
|
}
|
|
tmpName := tmp.Name()
|
|
removeTemp := true
|
|
defer func() {
|
|
if removeTemp {
|
|
removeShadowPlugin(tmpName)
|
|
}
|
|
}()
|
|
|
|
in, errOpen := os.Open(source)
|
|
if errOpen != nil {
|
|
if errClose := tmp.Close(); errClose != nil {
|
|
log.WithError(errClose).Debug("pluginhost: failed to close temp shadow plugin file")
|
|
}
|
|
return "", errOpen
|
|
}
|
|
defer func() {
|
|
if errClose := in.Close(); errClose != nil {
|
|
log.WithError(errClose).Debug("pluginhost: failed to close plugin source file")
|
|
}
|
|
}()
|
|
hasher := sha256.New()
|
|
copiedSize, errCopy := io.Copy(io.MultiWriter(tmp, hasher), in)
|
|
if errCopy != nil {
|
|
if errClose := tmp.Close(); errClose != nil {
|
|
log.WithError(errClose).Debug("pluginhost: failed to close temp shadow plugin file")
|
|
}
|
|
return "", errCopy
|
|
}
|
|
if errClose := tmp.Close(); errClose != nil {
|
|
return "", errClose
|
|
}
|
|
copiedDigest := hex.EncodeToString(hasher.Sum(nil))
|
|
target = shadowPluginPath(dir, file.ID, copiedDigest, ext)
|
|
if errPublish := publishShadowTempFile(tmpName, target, copiedSize, copiedDigest); errPublish != nil {
|
|
return "", errPublish
|
|
}
|
|
removeTemp = false
|
|
return target, nil
|
|
}
|
|
|
|
func publishShadowTempFile(tmpName string, target string, size int64, digest string) error {
|
|
if errPublish := publishShadowPlugin(tmpName, target); errPublish == nil {
|
|
return nil
|
|
}
|
|
if shadowPluginMatches(target, size, digest) {
|
|
removeShadowPlugin(tmpName)
|
|
return nil
|
|
}
|
|
if errRename := os.Rename(tmpName, target); errRename == nil {
|
|
return nil
|
|
}
|
|
if shadowPluginMatches(target, size, digest) {
|
|
removeShadowPlugin(tmpName)
|
|
return nil
|
|
}
|
|
if errRemove := os.Remove(target); errRemove != nil && !errors.Is(errRemove, os.ErrNotExist) {
|
|
if shadowPluginMatches(target, size, digest) {
|
|
removeShadowPlugin(tmpName)
|
|
return nil
|
|
}
|
|
removeShadowPlugin(target)
|
|
return fmt.Errorf("remove stale shadow plugin: %w", errRemove)
|
|
}
|
|
if errRename := os.Rename(tmpName, target); errRename != nil {
|
|
if shadowPluginMatches(target, size, digest) {
|
|
removeShadowPlugin(tmpName)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("move shadow plugin: %w", errRename)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func hashPluginFile(path string) (int64, string, error) {
|
|
cleaned := filepath.Clean(path)
|
|
file, errOpen := os.Open(cleaned)
|
|
if errOpen != nil {
|
|
return 0, "", errOpen
|
|
}
|
|
defer func() {
|
|
if errClose := file.Close(); errClose != nil {
|
|
log.WithError(errClose).Debug("pluginhost: failed to close plugin file after hashing")
|
|
}
|
|
}()
|
|
hasher := sha256.New()
|
|
size, errCopy := io.Copy(hasher, file)
|
|
if errCopy != nil {
|
|
return 0, "", errCopy
|
|
}
|
|
digest := hex.EncodeToString(hasher.Sum(nil))
|
|
if info, errStat := file.Stat(); errStat == nil && info.Mode().IsRegular() {
|
|
pluginDigestCache.Store(cleaned, cachedPluginDigest{
|
|
size: size,
|
|
modTimeNano: info.ModTime().UnixNano(),
|
|
digest: digest,
|
|
})
|
|
}
|
|
return size, digest, nil
|
|
}
|
|
|
|
func cachedOrHashPluginFile(path string) (int64, string, error) {
|
|
cleaned := filepath.Clean(path)
|
|
if info, errStat := os.Stat(cleaned); errStat == nil && info.Mode().IsRegular() {
|
|
if raw, okCache := pluginDigestCache.Load(cleaned); okCache {
|
|
if cached, okType := raw.(cachedPluginDigest); okType &&
|
|
cached.size == info.Size() &&
|
|
cached.modTimeNano == info.ModTime().UnixNano() &&
|
|
cached.digest != "" {
|
|
return cached.size, cached.digest, nil
|
|
}
|
|
}
|
|
}
|
|
return hashPluginFile(cleaned)
|
|
}
|
|
|
|
func shadowPluginBaseDir() string {
|
|
return filepath.Join(os.TempDir(), "cliproxy-pluginhost")
|
|
}
|
|
|
|
func shadowPluginLocalDir(sourcePath string) (string, error) {
|
|
dir := filepath.Join(filepath.Dir(filepath.Clean(sourcePath)), shadowPluginLocalDirName)
|
|
if errMkdir := os.MkdirAll(dir, 0o700); errMkdir != nil {
|
|
return "", errMkdir
|
|
}
|
|
return dir, nil
|
|
}
|
|
|
|
func shadowPluginDir() (string, error) {
|
|
dir := filepath.Join(shadowPluginBaseDir(), shadowPluginCacheDirName)
|
|
if errMkdir := os.MkdirAll(dir, 0o700); errMkdir != nil {
|
|
return "", errMkdir
|
|
}
|
|
return dir, nil
|
|
}
|
|
|
|
func shadowPluginFallbackDir(sourcePath string) (string, error) {
|
|
baseDir, errDir := shadowPluginDir()
|
|
if errDir != nil {
|
|
return "", errDir
|
|
}
|
|
sourceDir := filepath.Dir(filepath.Clean(sourcePath))
|
|
dir := filepath.Join(baseDir, shadowDirectoryDigest(sourceDir))
|
|
if errMkdir := os.MkdirAll(dir, 0o700); errMkdir != nil {
|
|
return "", errMkdir
|
|
}
|
|
return dir, nil
|
|
}
|
|
|
|
func shadowDirectoryDigest(dir string) string {
|
|
cleaned := filepath.Clean(dir)
|
|
if absDir, errAbs := filepath.Abs(cleaned); errAbs == nil {
|
|
cleaned = filepath.Clean(absDir)
|
|
}
|
|
sum := sha256.Sum256([]byte(cleaned))
|
|
return hex.EncodeToString(sum[:])[:shadowPluginDigestLength]
|
|
}
|
|
|
|
func shadowPluginProcessDirName(pid int) string {
|
|
return fmt.Sprintf("%s%d", shadowPluginProcessDirPrefix, pid)
|
|
}
|
|
|
|
func shadowPluginTempPattern(pid int, id string, extension string) string {
|
|
return fmt.Sprintf("%s%s%d-%s-*%s", shadowPluginTempPrefix, shadowPluginProcessDirPrefix, pid, id, extension)
|
|
}
|
|
|
|
func shadowTempFileOwnedByLiveProcess(name string) bool {
|
|
if !strings.HasPrefix(name, shadowPluginTempPrefix) {
|
|
return false
|
|
}
|
|
rest := strings.TrimPrefix(name, shadowPluginTempPrefix)
|
|
if !strings.HasPrefix(rest, shadowPluginProcessDirPrefix) {
|
|
return false
|
|
}
|
|
rest = strings.TrimPrefix(rest, shadowPluginProcessDirPrefix)
|
|
sep := strings.IndexByte(rest, '-')
|
|
if sep <= 0 {
|
|
return false
|
|
}
|
|
pid, errParse := strconv.Atoi(rest[:sep])
|
|
if errParse != nil || pid <= 0 {
|
|
return false
|
|
}
|
|
if pid == os.Getpid() {
|
|
return true
|
|
}
|
|
return shadowPluginProcessAlive(pid)
|
|
}
|
|
|
|
func removeStaleShadowTempFiles(dir string) {
|
|
entries, errRead := os.ReadDir(dir)
|
|
if errRead != nil {
|
|
return
|
|
}
|
|
for _, entry := range entries {
|
|
if entry == nil || entry.IsDir() {
|
|
continue
|
|
}
|
|
name := entry.Name()
|
|
if strings.HasPrefix(name, shadowPluginTempPrefix) && !shadowTempFileOwnedByLiveProcess(name) {
|
|
removeShadowPlugin(filepath.Join(dir, name))
|
|
}
|
|
}
|
|
}
|
|
|
|
func shadowDirHasLiveProcessActivity(entries []os.DirEntry) bool {
|
|
for _, entry := range entries {
|
|
if entry == nil || entry.IsDir() {
|
|
continue
|
|
}
|
|
name := entry.Name()
|
|
if strings.HasPrefix(name, shadowPluginTempPrefix) && shadowTempFileOwnedByLiveProcess(name) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func removeStaleShadowPlugins(dir string, keepNames ...string) {
|
|
pruneShadowDirForSourceDir(dir, "", keepNames)
|
|
}
|
|
|
|
func shadowSourceDirHasLiveProcessActivity(dir string, sourceDir string) bool {
|
|
if entries, errRead := os.ReadDir(dir); errRead == nil && shadowDirHasLiveProcessActivity(entries) {
|
|
return true
|
|
}
|
|
if sourceDir == "" {
|
|
return false
|
|
}
|
|
fallbackDir := filepath.Join(shadowPluginBaseDir(), shadowPluginCacheDirName, shadowDirectoryDigest(sourceDir))
|
|
if filepath.Clean(fallbackDir) == filepath.Clean(dir) {
|
|
return false
|
|
}
|
|
fallbackEntries, errRead := os.ReadDir(fallbackDir)
|
|
if errRead != nil {
|
|
return false
|
|
}
|
|
return shadowDirHasLiveProcessActivity(fallbackEntries)
|
|
}
|
|
|
|
func pruneShadowDirForSourceDir(dir string, sourceDir string, keepNames []string) {
|
|
entries, errRead := os.ReadDir(dir)
|
|
if errRead != nil {
|
|
return
|
|
}
|
|
keep := make(map[string]struct{}, len(keepNames))
|
|
for _, name := range keepNames {
|
|
if trimmed := strings.TrimSpace(name); trimmed != "" {
|
|
keep[filepath.Base(trimmed)] = struct{}{}
|
|
}
|
|
}
|
|
for _, entry := range entries {
|
|
if entry == nil || entry.IsDir() {
|
|
continue
|
|
}
|
|
name := entry.Name()
|
|
if strings.HasPrefix(name, shadowPluginTempPrefix) {
|
|
if !shadowTempFileOwnedByLiveProcess(name) {
|
|
removeShadowPlugin(filepath.Join(dir, name))
|
|
}
|
|
continue
|
|
}
|
|
if strings.HasPrefix(name, shadowPluginPrefix) {
|
|
if _, okKeep := keep[name]; okKeep {
|
|
continue
|
|
}
|
|
if hook := pruneShadowBeforeLockHook; hook != nil {
|
|
hook(name)
|
|
}
|
|
removeStaleShadowPluginCandidate(dir, sourceDir, name)
|
|
}
|
|
}
|
|
}
|
|
|
|
func removeStaleShadowPluginCandidate(dir string, sourceDir string, name string) {
|
|
unlockCoord, errLock := acquireShadowCoordLock(sourceDir, dir, true, true)
|
|
if errLock != nil {
|
|
return
|
|
}
|
|
defer unlockCoord()
|
|
if shadowSourceDirHasLiveProcessActivity(dir, sourceDir) {
|
|
return
|
|
}
|
|
if sourceDir != "" && shadowMatchesCurrentSourceDir(sourceDir, name) {
|
|
return
|
|
}
|
|
removeShadowPlugin(filepath.Join(dir, name))
|
|
}
|
|
|
|
func shadowMatchesCurrentSourceDir(sourceDir string, shadowFileName string) bool {
|
|
entries, errRead := os.ReadDir(sourceDir)
|
|
if errRead != nil {
|
|
return false
|
|
}
|
|
ext := filepath.Ext(shadowFileName)
|
|
for _, entry := range entries {
|
|
if entry == nil || !entry.Type().IsRegular() {
|
|
continue
|
|
}
|
|
filePath := filepath.Join(sourceDir, entry.Name())
|
|
file, okFile := pluginFileFromPath(filePath, ext)
|
|
if !okFile {
|
|
continue
|
|
}
|
|
if !strings.HasPrefix(shadowFileName, shadowPluginPrefix+file.ID+"-") {
|
|
continue
|
|
}
|
|
_, digest, errHash := cachedOrHashPluginFile(filePath)
|
|
if errHash != nil {
|
|
continue
|
|
}
|
|
if filepath.Base(shadowPluginPath("", file.ID, digest, ext)) == shadowFileName {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
type shadowDirTarget struct {
|
|
shadowDir string
|
|
sourceDir string
|
|
}
|
|
|
|
func cleanupStaleShadowPlugins(root string, activeFiles []pluginFile) {
|
|
keepNames := make([]string, 0, len(activeFiles))
|
|
seenDirs := make(map[string]struct{})
|
|
targets := make([]shadowDirTarget, 0, len(activeFiles)*2+4)
|
|
addShadowDirsForSourceDir := func(sourceDir string) {
|
|
cleanedSourceDir := filepath.Clean(sourceDir)
|
|
for _, dir := range []string{
|
|
filepath.Join(cleanedSourceDir, shadowPluginLocalDirName),
|
|
filepath.Join(shadowPluginBaseDir(), shadowPluginCacheDirName, shadowDirectoryDigest(cleanedSourceDir)),
|
|
} {
|
|
cleaned := filepath.Clean(dir)
|
|
if _, exists := seenDirs[cleaned]; exists {
|
|
continue
|
|
}
|
|
seenDirs[cleaned] = struct{}{}
|
|
targets = append(targets, shadowDirTarget{
|
|
shadowDir: cleaned,
|
|
sourceDir: cleanedSourceDir,
|
|
})
|
|
}
|
|
}
|
|
for _, candidateDir := range candidateDirs(root, runtime.GOOS, runtime.GOARCH) {
|
|
addShadowDirsForSourceDir(candidateDir)
|
|
}
|
|
seenSources := make(map[string]struct{}, len(activeFiles))
|
|
for _, file := range activeFiles {
|
|
id := strings.TrimSpace(file.ID)
|
|
path := strings.TrimSpace(file.Path)
|
|
if id == "" || path == "" {
|
|
continue
|
|
}
|
|
source := filepath.Clean(path)
|
|
if _, seen := seenSources[source]; seen {
|
|
continue
|
|
}
|
|
seenSources[source] = struct{}{}
|
|
addShadowDirsForSourceDir(filepath.Dir(source))
|
|
_, digest, errHash := cachedOrHashPluginFile(source)
|
|
if errHash != nil {
|
|
continue
|
|
}
|
|
keepNames = append(keepNames, filepath.Base(shadowPluginPath("", id, digest, filepath.Ext(source))))
|
|
}
|
|
for _, target := range targets {
|
|
pruneShadowDirForSourceDir(target.shadowDir, target.sourceDir, keepNames)
|
|
}
|
|
}
|
|
|
|
func shadowPluginPath(dir string, id string, digest string, extension string) string {
|
|
if len(digest) > shadowPluginDigestLength {
|
|
digest = digest[:shadowPluginDigestLength]
|
|
}
|
|
return filepath.Join(dir, shadowPluginPrefix+id+"-"+digest+extension)
|
|
}
|
|
|
|
func shadowPluginMatches(path string, size int64, digest string) bool {
|
|
info, errStat := os.Stat(path)
|
|
if errStat != nil {
|
|
return false
|
|
}
|
|
if !info.Mode().IsRegular() || info.Size() != size {
|
|
return false
|
|
}
|
|
file, errOpen := os.Open(path)
|
|
if errOpen != nil {
|
|
return false
|
|
}
|
|
defer func() {
|
|
if errClose := file.Close(); errClose != nil {
|
|
log.WithError(errClose).Debug("pluginhost: failed to close shadow plugin file")
|
|
}
|
|
}()
|
|
hasher := sha256.New()
|
|
if _, errCopy := io.Copy(hasher, file); errCopy != nil {
|
|
return false
|
|
}
|
|
return hex.EncodeToString(hasher.Sum(nil)) == digest
|
|
}
|