From f61374a1ef8ce3f01c976c8b7f7275a69d41b93e Mon Sep 17 00:00:00 2001 From: Christoph Witzko Date: Sun, 29 May 2022 23:08:49 +0200 Subject: [PATCH] feat: create plugin resolve system --- pkg/plugin/client.go | 22 +++-- pkg/plugin/discovery/discovery.go | 90 ++++++++----------- pkg/plugin/discovery/download.go | 58 ++---------- pkg/plugin/discovery/local.go | 62 +++++++------ .../{registry.go => resolver/registry/api.go} | 4 +- .../discovery/resolver/registry/registry.go | 62 +++++++++++++ pkg/plugin/discovery/resolver/resolver.go | 14 +++ pkg/plugin/manager/manager.go | 24 ++--- pkg/plugin/plugin.go | 84 +++++++++++++++++ pkg/plugin/plugin_test.go | 45 ++++++++++ pkg/plugin/{discovery => }/sysprocattr.go | 3 +- .../{discovery => }/sysprocattr_linux.go | 3 +- 12 files changed, 310 insertions(+), 161 deletions(-) rename pkg/plugin/discovery/{registry.go => resolver/registry/api.go} (94%) create mode 100644 pkg/plugin/discovery/resolver/registry/registry.go create mode 100644 pkg/plugin/discovery/resolver/resolver.go create mode 100644 pkg/plugin/plugin.go create mode 100644 pkg/plugin/plugin_test.go rename pkg/plugin/{discovery => }/sysprocattr.go (74%) rename pkg/plugin/{discovery => }/sysprocattr_linux.go (82%) diff --git a/pkg/plugin/client.go b/pkg/plugin/client.go index 2d57e7a0..ecce0327 100644 --- a/pkg/plugin/client.go +++ b/pkg/plugin/client.go @@ -14,12 +14,6 @@ import ( "github.com/hashicorp/go-plugin" ) -type PluginOpts struct { - Type string - PluginName string - Cmd *exec.Cmd -} - var runningClientsMx sync.Mutex var runningClients = make([]*plugin.Client, 0) @@ -31,11 +25,11 @@ func KillAllPlugins() { } } -func StartPlugin(opts *PluginOpts) (interface{}, error) { +func StartPlugin(pluginInfo *PluginInfo) (interface{}, error) { runningClientsMx.Lock() defer runningClientsMx.Unlock() logR, logW := io.Pipe() - pluginLogger := log.New(os.Stderr, fmt.Sprintf("[%s]: ", opts.PluginName), 0) + pluginLogger := log.New(os.Stderr, fmt.Sprintf("[%s]: ", pluginInfo.NormalizedName), 0) go func() { logLineScanner := bufio.NewScanner(logR) for logLineScanner.Scan() { @@ -47,16 +41,20 @@ func StartPlugin(opts *PluginOpts) (interface{}, error) { pluginLogger.Println(line) } }() + + cmd := exec.Command(pluginInfo.BinPath) + cmd.SysProcAttr = GetSysProcAttr() + client := plugin.NewClient(&plugin.ClientConfig{ HandshakeConfig: Handshake, VersionedPlugins: map[int]plugin.PluginSet{ 1: { - opts.Type: &GRPCWrapper{ - Type: opts.Type, + pluginInfo.Type: &GRPCWrapper{ + Type: pluginInfo.Type, }, }, }, - Cmd: opts.Cmd, + Cmd: cmd, AllowedProtocols: []plugin.Protocol{plugin.ProtocolGRPC}, Logger: hclog.NewNullLogger(), Stderr: logW, @@ -67,7 +65,7 @@ func StartPlugin(opts *PluginOpts) (interface{}, error) { client.Kill() return nil, err } - raw, err := rpcClient.Dispense(opts.Type) + raw, err := rpcClient.Dispense(pluginInfo.Type) if err != nil { client.Kill() return nil, err diff --git a/pkg/plugin/discovery/discovery.go b/pkg/plugin/discovery/discovery.go index f9c3a751..bbe15645 100644 --- a/pkg/plugin/discovery/discovery.go +++ b/pkg/plugin/discovery/discovery.go @@ -2,82 +2,62 @@ package discovery import ( "errors" - "os/exec" - "strings" + "fmt" - "github.com/Masterminds/semver/v3" - "github.com/go-semantic-release/semantic-release/v2/pkg/analyzer" - "github.com/go-semantic-release/semantic-release/v2/pkg/condition" "github.com/go-semantic-release/semantic-release/v2/pkg/config" - "github.com/go-semantic-release/semantic-release/v2/pkg/generator" - "github.com/go-semantic-release/semantic-release/v2/pkg/hooks" "github.com/go-semantic-release/semantic-release/v2/pkg/plugin" - "github.com/go-semantic-release/semantic-release/v2/pkg/provider" - "github.com/go-semantic-release/semantic-release/v2/pkg/updater" + "github.com/go-semantic-release/semantic-release/v2/pkg/plugin/discovery/resolver" + "github.com/go-semantic-release/semantic-release/v2/pkg/plugin/discovery/resolver/registry" ) type Discovery struct { - config *config.Config + config *config.Config + resolvers map[string]resolver.Resolver } func New(config *config.Config) (*Discovery, error) { - return &Discovery{config}, nil + registryResolver := registry.NewResolver() + return &Discovery{ + config: config, + resolvers: map[string]resolver.Resolver{ + "default": registryResolver, + "registry": registryResolver, + }, + }, nil } -func getPluginType(t string) string { - switch t { - case analyzer.CommitAnalyzerPluginName: - return "commit-analyzer" - case condition.CIConditionPluginName: - return "condition" - case generator.ChangelogGeneratorPluginName: - return "changelog-generator" - case provider.PluginName: - return "provider" - case updater.FilesUpdaterPluginName: - return "files-updater" - case hooks.PluginName: - return "hooks" +func (d *Discovery) fetchPlugin(pluginInfo *plugin.PluginInfo) (string, error) { + pluginResolver, ok := d.resolvers[pluginInfo.Resolver] + if !ok { + return "", fmt.Errorf("resolver %s not found", pluginInfo.Resolver) } - return "" -} -func (d *Discovery) FindPlugin(t, name string) (*plugin.PluginOpts, error) { - pType := getPluginType(t) - if pType == "" { - return nil, errors.New("invalid plugin type") + downloadInfo, err := pluginResolver.ResolvePlugin(pluginInfo) + if err != nil { + return "", err } - var cons *semver.Constraints - if ve := strings.SplitN(name, "@", 2); len(ve) > 1 { - v, err := semver.NewConstraint(ve[1]) - if err != nil { - return nil, err - } - name = ve[0] - cons = v - } + return downloadPlugin(pluginInfo, downloadInfo, d.config.ShowProgress) +} - pName := strings.ToLower(pType + "-" + name) - pPath := getPluginPath(pName) - if err := ensurePluginDir(pPath); err != nil { +func (d *Discovery) FindPlugin(t, name string) (*plugin.PluginInfo, error) { + pInfo, err := plugin.GetPluginInfo(t, name) + if err != nil { + return nil, err + } + if err := setAndEnsurePluginPath(pInfo); err != nil { return nil, err } - binPath, err := findPluginLocally(pPath, cons) - if err != nil { - binPath, err = fetchPlugin(pName, pPath, cons, d.config.ShowProgress) + binPath, err := findPluginLocally(pInfo) + if errors.Is(err, ErrPluginNotFound) { + binPath, err = d.fetchPlugin(pInfo) if err != nil { return nil, err } + } else if err != nil { + return nil, err } - - cmd := exec.Command(binPath) - cmd.SysProcAttr = GetSysProcAttr() - - return &plugin.PluginOpts{ - Type: t, - PluginName: pName, - Cmd: cmd, - }, nil + pInfo.BinPath = binPath + return pInfo, nil } diff --git a/pkg/plugin/discovery/download.go b/pkg/plugin/discovery/download.go index 7fba6d37..54bdee0c 100644 --- a/pkg/plugin/discovery/download.go +++ b/pkg/plugin/discovery/download.go @@ -3,16 +3,13 @@ package discovery import ( "crypto/sha256" "encoding/hex" - "errors" - "fmt" "os" "path" - "runtime" - "sort" "time" - "github.com/Masterminds/semver/v3" "github.com/cavaliergopher/grab/v3" + "github.com/go-semantic-release/semantic-release/v2/pkg/plugin" + "github.com/go-semantic-release/semantic-release/v2/pkg/plugin/discovery/resolver" "github.com/schollz/progressbar/v3" ) @@ -47,13 +44,14 @@ func showDownloadProgressBar(name string, res *grab.Response) { <-done } -func downloadPlugin(name, targetPath, downloadUrl, checksum string, showProgress bool) (string, error) { - req, err := grab.NewRequest(targetPath, downloadUrl) +func downloadPlugin(pluginInfo *plugin.PluginInfo, downloadInfo *resolver.PluginDownloadInfo, showProgress bool) (string, error) { + targetPath := path.Join(pluginInfo.PluginPath, downloadInfo.Version, downloadInfo.FileName) + req, err := grab.NewRequest(targetPath, downloadInfo.URL) if err != nil { return "", err } - if checksum != "" { - sum, err := hex.DecodeString(checksum) + if downloadInfo.Checksum != "" { + sum, err := hex.DecodeString(downloadInfo.Checksum) if err != nil { return "", err } @@ -62,7 +60,7 @@ func downloadPlugin(name, targetPath, downloadUrl, checksum string, showProgress res := grab.DefaultClient.Do(req) if showProgress { - showDownloadProgressBar(name, res) + showDownloadProgressBar(pluginInfo.NormalizedName, res) } if err := res.Err(); err != nil { return "", err @@ -72,43 +70,3 @@ func downloadPlugin(name, targetPath, downloadUrl, checksum string, showProgress } return res.Filename, nil } - -func fetchPlugin(name, pth string, cons *semver.Constraints, showProgress bool) (string, error) { - pluginInfo, err := getPluginInfo(name) - if err != nil { - return "", err - } - - foundVersion := "" - if cons == nil { - foundVersion = pluginInfo.LatestRelease - } else { - versions := make(semver.Collection, 0) - for v := range pluginInfo.Versions { - pv, err := semver.NewVersion(v) - if err != nil { - return "", err - } - versions = append(versions, pv) - } - sort.Sort(sort.Reverse(versions)) - for _, v := range versions { - if cons.Check(v) { - foundVersion = v.String() - break - } - } - } - - if foundVersion == "" { - return "", errors.New("version not found") - } - - releaseAsset := pluginInfo.Versions[foundVersion].getMatchingAsset() - if releaseAsset == nil { - return "", fmt.Errorf("a matching plugin was not found for %s/%s", runtime.GOOS, runtime.GOARCH) - } - - targetPath := path.Join(pth, foundVersion, releaseAsset.FileName) - return downloadPlugin(name, targetPath, releaseAsset.URL, releaseAsset.Checksum, showProgress) -} diff --git a/pkg/plugin/discovery/local.go b/pkg/plugin/discovery/local.go index e9fef00d..d01f477a 100644 --- a/pkg/plugin/discovery/local.go +++ b/pkg/plugin/discovery/local.go @@ -8,6 +8,8 @@ import ( "runtime" "sort" + "github.com/go-semantic-release/semantic-release/v2/pkg/plugin" + "github.com/Masterminds/semver/v3" ) @@ -15,64 +17,70 @@ const PluginDir = ".semrel" var osArchDir = runtime.GOOS + "_" + runtime.GOARCH -func getPluginPath(name string) string { - pElem := append([]string{PluginDir}, osArchDir, name) - return path.Join(pElem...) -} - -func ensurePluginDir(pth string) error { - _, err := os.Stat(pth) - if os.IsNotExist(err) { - return os.MkdirAll(pth, 0755) +func setAndEnsurePluginPath(pluginInfo *plugin.PluginInfo) error { + pluginPath := path.Join(PluginDir, osArchDir, pluginInfo.NormalizedName) + if _, err := os.Stat(pluginPath); os.IsNotExist(err) { + if err := os.MkdirAll(pluginPath, 0755); err != nil { + return err + } + } else if err != nil { + return err } - return err + pluginInfo.PluginPath = pluginPath + return nil } -func getMatchingVersionDir(pth string, cons *semver.Constraints) (string, error) { - vDirs, err := ioutil.ReadDir(pth) +var ErrPluginNotFound = errors.New("no plugin was found") + +func getMatchingVersionDir(pluginInfo *plugin.PluginInfo) (string, error) { + vDirs, err := ioutil.ReadDir(pluginInfo.PluginPath) if err != nil { return "", err } - foundVers := make(semver.Collection, 0) + foundVersions := make(semver.Collection, 0) for _, f := range vDirs { if f.IsDir() { fVer, err := semver.NewVersion(f.Name()) if err != nil { continue } - foundVers = append(foundVers, fVer) + foundVersions = append(foundVersions, fVer) } } - if len(foundVers) == 0 { - return "", errors.New("no installed version found") + if len(foundVersions) == 0 { + return "", nil } - sort.Sort(sort.Reverse(foundVers)) + sort.Sort(sort.Reverse(foundVersions)) - if cons == nil { - return path.Join(pth, foundVers[0].String()), nil + if pluginInfo.Constraint == nil { + return path.Join(pluginInfo.PluginPath, foundVersions[0].String()), nil } - for _, v := range foundVers { - if cons.Check(v) { - return path.Join(pth, v.String()), nil + for _, v := range foundVersions { + if pluginInfo.Constraint.Check(v) { + return path.Join(pluginInfo.PluginPath, v.String()), nil } } - return "", errors.New("no matching version found") + return "", nil } -func findPluginLocally(pth string, cons *semver.Constraints) (string, error) { - vPth, err := getMatchingVersionDir(pth, cons) +func findPluginLocally(pluginInfo *plugin.PluginInfo) (string, error) { + vPth, err := getMatchingVersionDir(pluginInfo) if err != nil { return "", err } + if vPth == "" { + return "", ErrPluginNotFound + } + files, err := ioutil.ReadDir(vPth) if err != nil { return "", err } if len(files) == 0 { - return "", errors.New("no plugins found") + return "", ErrPluginNotFound } for _, f := range files { if f.IsDir() { @@ -83,5 +91,5 @@ func findPluginLocally(pth string, cons *semver.Constraints) (string, error) { } return path.Join(vPth, f.Name()), nil } - return "", errors.New("no matching plugin found") + return "", ErrPluginNotFound } diff --git a/pkg/plugin/discovery/registry.go b/pkg/plugin/discovery/resolver/registry/api.go similarity index 94% rename from pkg/plugin/discovery/registry.go rename to pkg/plugin/discovery/resolver/registry/api.go index 693fbc8a..29812b6b 100644 --- a/pkg/plugin/discovery/registry.go +++ b/pkg/plugin/discovery/resolver/registry/api.go @@ -1,4 +1,4 @@ -package discovery +package registry import ( "encoding/json" @@ -34,8 +34,6 @@ func (r *apiPluginRelease) getMatchingAsset() *apiPluginAsset { } type apiPlugin struct { - Type string - Name string LatestRelease string Versions map[string]*apiPluginRelease } diff --git a/pkg/plugin/discovery/resolver/registry/registry.go b/pkg/plugin/discovery/resolver/registry/registry.go new file mode 100644 index 00000000..a3ad0376 --- /dev/null +++ b/pkg/plugin/discovery/resolver/registry/registry.go @@ -0,0 +1,62 @@ +package registry + +import ( + "errors" + "fmt" + "runtime" + "sort" + + "github.com/Masterminds/semver/v3" + "github.com/go-semantic-release/semantic-release/v2/pkg/plugin" + "github.com/go-semantic-release/semantic-release/v2/pkg/plugin/discovery/resolver" +) + +type RegistryResolver struct { +} + +func NewResolver() *RegistryResolver { + return &RegistryResolver{} +} + +func (r RegistryResolver) ResolvePlugin(pluginInfo *plugin.PluginInfo) (*resolver.PluginDownloadInfo, error) { + pluginApiRes, err := getPluginInfo(pluginInfo.NormalizedName) + if err != nil { + return nil, err + } + + foundVersion := "" + if pluginInfo.Constraint == nil { + foundVersion = pluginApiRes.LatestRelease + } else { + versions := make(semver.Collection, 0) + for v := range pluginApiRes.Versions { + pv, err := semver.NewVersion(v) + if err != nil { + return nil, err + } + versions = append(versions, pv) + } + sort.Sort(sort.Reverse(versions)) + for _, v := range versions { + if pluginInfo.Constraint.Check(v) { + foundVersion = v.String() + break + } + } + } + + if foundVersion == "" { + return nil, errors.New("version not found") + } + + releaseAsset := pluginApiRes.Versions[foundVersion].getMatchingAsset() + if releaseAsset == nil { + return nil, fmt.Errorf("a matching plugin was not found for %s/%s", runtime.GOOS, runtime.GOARCH) + } + return &resolver.PluginDownloadInfo{ + URL: releaseAsset.URL, + Checksum: releaseAsset.Checksum, + FileName: releaseAsset.FileName, + Version: foundVersion, + }, nil +} diff --git a/pkg/plugin/discovery/resolver/resolver.go b/pkg/plugin/discovery/resolver/resolver.go new file mode 100644 index 00000000..c114e553 --- /dev/null +++ b/pkg/plugin/discovery/resolver/resolver.go @@ -0,0 +1,14 @@ +package resolver + +import "github.com/go-semantic-release/semantic-release/v2/pkg/plugin" + +type PluginDownloadInfo struct { + URL string + Checksum string + FileName string + Version string +} + +type Resolver interface { + ResolvePlugin(*plugin.PluginInfo) (*PluginDownloadInfo, error) +} diff --git a/pkg/plugin/manager/manager.go b/pkg/plugin/manager/manager.go index 384db31b..cf8aae71 100644 --- a/pkg/plugin/manager/manager.go +++ b/pkg/plugin/manager/manager.go @@ -29,12 +29,12 @@ func New(config *config.Config) (*PluginManager, error) { } func (m *PluginManager) GetCICondition() (condition.CICondition, error) { - opts, err := m.discovery.FindPlugin(condition.CIConditionPluginName, m.config.CIConditionPlugin) + pluginInfo, err := m.discovery.FindPlugin(condition.CIConditionPluginName, m.config.CIConditionPlugin) if err != nil { return nil, err } - cic, err := plugin.StartPlugin(opts) + cic, err := plugin.StartPlugin(pluginInfo) if err != nil { return nil, err } @@ -42,12 +42,12 @@ func (m *PluginManager) GetCICondition() (condition.CICondition, error) { } func (m *PluginManager) GetProvider() (provider.Provider, error) { - opts, err := m.discovery.FindPlugin(provider.PluginName, m.config.ProviderPlugin) + pluginInfo, err := m.discovery.FindPlugin(provider.PluginName, m.config.ProviderPlugin) if err != nil { return nil, err } - prov, err := plugin.StartPlugin(opts) + prov, err := plugin.StartPlugin(pluginInfo) if err != nil { return nil, err } @@ -55,12 +55,12 @@ func (m *PluginManager) GetProvider() (provider.Provider, error) { } func (m *PluginManager) GetCommitAnalyzer() (analyzer.CommitAnalyzer, error) { - opts, err := m.discovery.FindPlugin(analyzer.CommitAnalyzerPluginName, m.config.CommitAnalyzerPlugin) + pluginInfo, err := m.discovery.FindPlugin(analyzer.CommitAnalyzerPluginName, m.config.CommitAnalyzerPlugin) if err != nil { return nil, err } - ca, err := plugin.StartPlugin(opts) + ca, err := plugin.StartPlugin(pluginInfo) if err != nil { return nil, err } @@ -68,12 +68,12 @@ func (m *PluginManager) GetCommitAnalyzer() (analyzer.CommitAnalyzer, error) { } func (m *PluginManager) GetChangelogGenerator() (generator.ChangelogGenerator, error) { - opts, err := m.discovery.FindPlugin(generator.ChangelogGeneratorPluginName, m.config.ChangelogGeneratorPlugin) + pluginInfo, err := m.discovery.FindPlugin(generator.ChangelogGeneratorPluginName, m.config.ChangelogGeneratorPlugin) if err != nil { return nil, err } - cg, err := plugin.StartPlugin(opts) + cg, err := plugin.StartPlugin(pluginInfo) if err != nil { return nil, err } @@ -83,12 +83,12 @@ func (m *PluginManager) GetChangelogGenerator() (generator.ChangelogGenerator, e func (m *PluginManager) GetChainedUpdater() (*updater.ChainedUpdater, error) { updaters := make([]updater.FilesUpdater, 0) for _, pl := range m.config.FilesUpdaterPlugins { - opts, err := m.discovery.FindPlugin(updater.FilesUpdaterPluginName, pl) + pluginInfo, err := m.discovery.FindPlugin(updater.FilesUpdaterPluginName, pl) if err != nil { return nil, err } - upd, err := plugin.StartPlugin(opts) + upd, err := plugin.StartPlugin(pluginInfo) if err != nil { return nil, err } @@ -103,12 +103,12 @@ func (m *PluginManager) GetChainedUpdater() (*updater.ChainedUpdater, error) { func (m *PluginManager) GetChainedHooksExecutor() (*hooks.ChainedHooksExecutor, error) { hooksChain := make([]hooks.Hooks, 0) for _, pl := range m.config.HooksPlugins { - opts, err := m.discovery.FindPlugin(hooks.PluginName, pl) + pluginInfo, err := m.discovery.FindPlugin(hooks.PluginName, pl) if err != nil { return nil, err } - hp, err := plugin.StartPlugin(opts) + hp, err := plugin.StartPlugin(pluginInfo) if err != nil { return nil, err } diff --git a/pkg/plugin/plugin.go b/pkg/plugin/plugin.go new file mode 100644 index 00000000..7c4dc22c --- /dev/null +++ b/pkg/plugin/plugin.go @@ -0,0 +1,84 @@ +package plugin + +import ( + "fmt" + "strings" + + "github.com/Masterminds/semver/v3" + "github.com/go-semantic-release/semantic-release/v2/pkg/analyzer" + "github.com/go-semantic-release/semantic-release/v2/pkg/condition" + "github.com/go-semantic-release/semantic-release/v2/pkg/generator" + "github.com/go-semantic-release/semantic-release/v2/pkg/hooks" + "github.com/go-semantic-release/semantic-release/v2/pkg/provider" + "github.com/go-semantic-release/semantic-release/v2/pkg/updater" +) + +type PluginInfo struct { + Type string + Name string + NormalizedName string + Constraint *semver.Constraints + Resolver string + PluginPath string + BinPath string +} + +func normalizedPluginType(t string) string { + switch t { + case analyzer.CommitAnalyzerPluginName: + return "commit-analyzer" + case condition.CIConditionPluginName: + return "condition" + case generator.ChangelogGeneratorPluginName: + return "changelog-generator" + case provider.PluginName: + return "provider" + case updater.FilesUpdaterPluginName: + return "files-updater" + case hooks.PluginName: + return "hooks" + } + return "" +} + +func GetPluginInfo(pluginType, pluginName string) (*PluginInfo, error) { + nPluginType := normalizedPluginType(pluginType) + if nPluginType == "" { + return nil, fmt.Errorf("invalid plugin type: %s", pluginType) + } + resolver := "default" + name := pluginName + normalizedName := fmt.Sprintf("%s-%s", nPluginType, pluginName) + if strings.Contains(name, ":") { + parts := strings.SplitN(name, ":", 2) + resolver = parts[0] + name = parts[1] + normalizedName = strings.ReplaceAll(normalizedName, ":", "-") + } + if strings.Contains(name, "/") { + parts := strings.SplitN(name, "/", 2) + name = parts[1] + normalizedName = strings.ReplaceAll(normalizedName, "/", "-") + } + + var constraint *semver.Constraints + if strings.Contains(name, "@") { + parts := strings.SplitN(name, "@", 2) + v, err := semver.NewConstraint(parts[1]) + if err != nil { + return nil, err + } + name = parts[0] + constraint = v + parts = strings.SplitN(normalizedName, "@", 2) + normalizedName = parts[0] + } + + return &PluginInfo{ + Type: pluginType, + Name: name, + NormalizedName: normalizedName, + Constraint: constraint, + Resolver: resolver, + }, nil +} diff --git a/pkg/plugin/plugin_test.go b/pkg/plugin/plugin_test.go new file mode 100644 index 00000000..c5812bad --- /dev/null +++ b/pkg/plugin/plugin_test.go @@ -0,0 +1,45 @@ +package plugin + +import ( + "testing" + + "github.com/Masterminds/semver/v3" + + "github.com/stretchr/testify/require" +) + +func parseConstraint(c string) *semver.Constraints { + constraint, _ := semver.NewConstraint(c) + return constraint +} + +func TestGetPluginInfo(t *testing.T) { + testCases := []struct { + t string + input string + results *PluginInfo + }{ + {"provider", "git", &PluginInfo{ + Type: "provider", Name: "git", NormalizedName: "provider-git", Resolver: "default", + }}, + {"provider", "github:myorg/myplugin", &PluginInfo{ + Type: "provider", Name: "myplugin", NormalizedName: "provider-github-myorg-myplugin", Resolver: "github", + }}, + {"provider", "github:myorg/myplugin", &PluginInfo{ + Type: "provider", Name: "myplugin", NormalizedName: "provider-github-myorg-myplugin", Resolver: "github", + }}, + {"provider", "github:myorg/myplugin@^1.0.0", &PluginInfo{ + Type: "provider", Name: "myplugin", NormalizedName: "provider-github-myorg-myplugin", Resolver: "github", + Constraint: parseConstraint("^1.0.0"), + }}, + {"provider", "git@2.0.0", &PluginInfo{ + Type: "provider", Name: "git", NormalizedName: "provider-git", Resolver: "default", + Constraint: parseConstraint("2.0.0"), + }}, + } + for _, testCase := range testCases { + results, err := GetPluginInfo(testCase.t, testCase.input) + require.NoError(t, err) + require.Equal(t, testCase.results, results) + } +} diff --git a/pkg/plugin/discovery/sysprocattr.go b/pkg/plugin/sysprocattr.go similarity index 74% rename from pkg/plugin/discovery/sysprocattr.go rename to pkg/plugin/sysprocattr.go index 20809817..e6116ba3 100644 --- a/pkg/plugin/discovery/sysprocattr.go +++ b/pkg/plugin/sysprocattr.go @@ -1,6 +1,7 @@ +//go:build !linux // +build !linux -package discovery +package plugin import "syscall" diff --git a/pkg/plugin/discovery/sysprocattr_linux.go b/pkg/plugin/sysprocattr_linux.go similarity index 82% rename from pkg/plugin/discovery/sysprocattr_linux.go rename to pkg/plugin/sysprocattr_linux.go index ec1f959a..a55b0c4e 100644 --- a/pkg/plugin/discovery/sysprocattr_linux.go +++ b/pkg/plugin/sysprocattr_linux.go @@ -1,6 +1,7 @@ +//go:build linux // +build linux -package discovery +package plugin import "syscall"