2018-10-01 22:47:12 +03:00
|
|
|
// Package core contains the target-agnostic code to define and run a bridge
|
2018-09-21 13:54:48 +03:00
|
|
|
package core
|
|
|
|
|
2018-09-21 19:23:46 +03:00
|
|
|
import (
|
|
|
|
"fmt"
|
2018-09-24 16:25:15 +03:00
|
|
|
"reflect"
|
|
|
|
"regexp"
|
2019-06-06 02:05:38 +03:00
|
|
|
"sort"
|
2018-09-21 19:23:46 +03:00
|
|
|
"strings"
|
2019-05-03 01:02:50 +03:00
|
|
|
"time"
|
2018-09-21 13:54:48 +03:00
|
|
|
|
2019-06-15 03:33:06 +03:00
|
|
|
"github.com/pkg/errors"
|
|
|
|
|
2018-09-21 19:23:46 +03:00
|
|
|
"github.com/MichaelMure/git-bug/cache"
|
|
|
|
"github.com/MichaelMure/git-bug/repository"
|
|
|
|
)
|
|
|
|
|
2019-02-24 14:56:42 +03:00
|
|
|
var ErrImportNotSupported = errors.New("import is not supported")
|
|
|
|
var ErrExportNotSupported = errors.New("export is not supported")
|
2018-09-21 19:23:46 +03:00
|
|
|
|
2019-06-15 03:33:06 +03:00
|
|
|
const (
|
|
|
|
keyTarget = "target"
|
|
|
|
bridgeConfigKeyPrefix = "git-bug.bridge"
|
|
|
|
)
|
2018-11-21 20:56:12 +03:00
|
|
|
|
2018-09-24 16:25:15 +03:00
|
|
|
var bridgeImpl map[string]reflect.Type
|
|
|
|
|
2019-05-24 22:03:31 +03:00
|
|
|
// BridgeParams holds parameters to simplify the bridge configuration without
|
|
|
|
// having to make terminal prompts.
|
|
|
|
type BridgeParams struct {
|
|
|
|
Owner string
|
|
|
|
Project string
|
|
|
|
URL string
|
|
|
|
Token string
|
|
|
|
}
|
|
|
|
|
2018-09-21 19:23:46 +03:00
|
|
|
// Bridge is a wrapper around a BridgeImpl that will bind low-level
|
|
|
|
// implementation with utility code to provide high-level functions.
|
|
|
|
type Bridge struct {
|
2018-10-06 12:55:16 +03:00
|
|
|
Name string
|
|
|
|
repo *cache.RepoCache
|
|
|
|
impl BridgeImpl
|
|
|
|
importer Importer
|
|
|
|
exporter Exporter
|
|
|
|
conf Configuration
|
|
|
|
initDone bool
|
2018-09-21 13:54:48 +03:00
|
|
|
}
|
|
|
|
|
2018-09-24 16:25:15 +03:00
|
|
|
// Register will register a new BridgeImpl
|
|
|
|
func Register(impl BridgeImpl) {
|
|
|
|
if bridgeImpl == nil {
|
|
|
|
bridgeImpl = make(map[string]reflect.Type)
|
|
|
|
}
|
|
|
|
bridgeImpl[impl.Target()] = reflect.TypeOf(impl)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Targets return all known bridge implementation target
|
|
|
|
func Targets() []string {
|
|
|
|
var result []string
|
|
|
|
|
|
|
|
for key := range bridgeImpl {
|
|
|
|
result = append(result, key)
|
|
|
|
}
|
|
|
|
|
2019-06-06 02:05:38 +03:00
|
|
|
sort.Strings(result)
|
|
|
|
|
2018-09-24 16:25:15 +03:00
|
|
|
return result
|
|
|
|
}
|
|
|
|
|
2018-10-01 22:47:12 +03:00
|
|
|
// Instantiate a new Bridge for a repo, from the given target and name
|
2018-09-24 16:25:15 +03:00
|
|
|
func NewBridge(repo *cache.RepoCache, target string, name string) (*Bridge, error) {
|
|
|
|
implType, ok := bridgeImpl[target]
|
|
|
|
if !ok {
|
|
|
|
return nil, fmt.Errorf("unknown bridge target %v", target)
|
|
|
|
}
|
|
|
|
|
|
|
|
impl := reflect.New(implType).Elem().Interface().(BridgeImpl)
|
|
|
|
|
|
|
|
bridge := &Bridge{
|
|
|
|
Name: name,
|
|
|
|
repo: repo,
|
2018-09-21 19:23:46 +03:00
|
|
|
impl: impl,
|
|
|
|
}
|
2018-09-24 16:25:15 +03:00
|
|
|
|
|
|
|
return bridge, nil
|
|
|
|
}
|
|
|
|
|
2019-06-15 03:33:06 +03:00
|
|
|
// LoadBridge instantiate a new bridge from a repo configuration
|
|
|
|
func LoadBridge(repo *cache.RepoCache, name string) (*Bridge, error) {
|
2019-06-17 01:10:21 +03:00
|
|
|
conf, err := loadConfig(repo, name)
|
2018-09-24 18:11:50 +03:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2019-06-15 03:33:06 +03:00
|
|
|
|
2019-06-17 01:10:21 +03:00
|
|
|
target := conf[keyTarget]
|
|
|
|
bridge, err := NewBridge(repo, target, name)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2019-06-15 03:33:06 +03:00
|
|
|
}
|
|
|
|
|
2019-06-17 01:10:21 +03:00
|
|
|
err = bridge.impl.ValidateConfig(conf)
|
2019-06-15 03:33:06 +03:00
|
|
|
if err != nil {
|
|
|
|
return nil, errors.Wrap(err, "invalid configuration")
|
|
|
|
}
|
2018-09-24 18:11:50 +03:00
|
|
|
|
2019-06-17 01:10:21 +03:00
|
|
|
// will avoid reloading configuration before an export or import call
|
|
|
|
bridge.conf = conf
|
2019-06-15 03:33:06 +03:00
|
|
|
return bridge, nil
|
2018-09-24 18:11:50 +03:00
|
|
|
}
|
|
|
|
|
2018-10-01 22:47:12 +03:00
|
|
|
// Attempt to retrieve a default bridge for the given repo. If zero or multiple
|
|
|
|
// bridge exist, it fails.
|
2018-09-24 18:11:50 +03:00
|
|
|
func DefaultBridge(repo *cache.RepoCache) (*Bridge, error) {
|
|
|
|
bridges, err := ConfiguredBridges(repo)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(bridges) == 0 {
|
|
|
|
return nil, fmt.Errorf("no configured bridge")
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(bridges) > 1 {
|
2018-12-05 01:43:22 +03:00
|
|
|
return nil, fmt.Errorf("multiple bridge are configured, you need to select one explicitely")
|
2018-09-24 18:11:50 +03:00
|
|
|
}
|
|
|
|
|
2019-06-15 03:33:06 +03:00
|
|
|
return LoadBridge(repo, bridges[0])
|
2018-09-24 18:11:50 +03:00
|
|
|
}
|
|
|
|
|
2018-10-01 22:47:12 +03:00
|
|
|
// ConfiguredBridges return the list of bridge that are configured for the given
|
|
|
|
// repo
|
2018-09-24 16:25:15 +03:00
|
|
|
func ConfiguredBridges(repo repository.RepoCommon) ([]string, error) {
|
2018-11-21 20:56:12 +03:00
|
|
|
configs, err := repo.ReadConfigs(bridgeConfigKeyPrefix + ".")
|
2018-09-24 16:25:15 +03:00
|
|
|
if err != nil {
|
|
|
|
return nil, errors.Wrap(err, "can't read configured bridges")
|
|
|
|
}
|
|
|
|
|
2019-06-15 03:33:06 +03:00
|
|
|
re, err := regexp.Compile(bridgeConfigKeyPrefix + `.([^.]+)`)
|
2018-09-24 16:25:15 +03:00
|
|
|
if err != nil {
|
2018-09-24 17:24:38 +03:00
|
|
|
panic(err)
|
2018-09-24 16:25:15 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
set := make(map[string]interface{})
|
|
|
|
|
|
|
|
for key := range configs {
|
|
|
|
res := re.FindStringSubmatch(key)
|
|
|
|
|
|
|
|
if res == nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
set[res[1]] = nil
|
|
|
|
}
|
|
|
|
|
|
|
|
result := make([]string, len(set))
|
|
|
|
|
|
|
|
i := 0
|
|
|
|
for key := range set {
|
|
|
|
result[i] = key
|
|
|
|
i++
|
|
|
|
}
|
|
|
|
|
|
|
|
return result, nil
|
|
|
|
}
|
|
|
|
|
2018-10-01 22:47:12 +03:00
|
|
|
// Remove a configured bridge
|
2019-06-15 03:33:06 +03:00
|
|
|
func RemoveBridge(repo repository.RepoCommon, name string) error {
|
|
|
|
re, err := regexp.Compile(`^[a-zA-Z0-9]+`)
|
2018-09-24 17:24:38 +03:00
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
|
2019-06-15 03:33:06 +03:00
|
|
|
if !re.MatchString(name) {
|
|
|
|
return fmt.Errorf("bad bridge fullname: %s", name)
|
2018-09-24 16:25:15 +03:00
|
|
|
}
|
|
|
|
|
2019-06-15 03:33:06 +03:00
|
|
|
keyPrefix := fmt.Sprintf("git-bug.bridge.%s", name)
|
2018-09-24 17:24:38 +03:00
|
|
|
return repo.RmConfigs(keyPrefix)
|
2018-09-21 13:54:48 +03:00
|
|
|
}
|
|
|
|
|
2018-10-01 22:47:12 +03:00
|
|
|
// Configure run the target specific configuration process
|
2019-05-24 22:03:31 +03:00
|
|
|
func (b *Bridge) Configure(params BridgeParams) error {
|
|
|
|
conf, err := b.impl.Configure(b.repo, params)
|
2018-09-21 19:23:46 +03:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-06-15 03:33:06 +03:00
|
|
|
err = b.impl.ValidateConfig(conf)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("invalid configuration: %v", err)
|
|
|
|
}
|
2018-09-24 16:25:15 +03:00
|
|
|
|
2019-06-15 03:33:06 +03:00
|
|
|
b.conf = conf
|
2018-09-24 16:25:15 +03:00
|
|
|
return b.storeConfig(conf)
|
2018-09-21 13:54:48 +03:00
|
|
|
}
|
|
|
|
|
2018-09-24 16:25:15 +03:00
|
|
|
func (b *Bridge) storeConfig(conf Configuration) error {
|
2018-09-21 19:23:46 +03:00
|
|
|
for key, val := range conf {
|
2019-06-15 03:33:06 +03:00
|
|
|
storeKey := fmt.Sprintf("git-bug.bridge.%s.%s", b.Name, key)
|
2018-09-21 19:23:46 +03:00
|
|
|
|
2018-09-24 16:25:15 +03:00
|
|
|
err := b.repo.StoreConfig(storeKey, val)
|
2018-09-21 19:23:46 +03:00
|
|
|
if err != nil {
|
2018-09-24 16:25:15 +03:00
|
|
|
return errors.Wrap(err, "error while storing bridge configuration")
|
2018-09-21 19:23:46 +03:00
|
|
|
}
|
|
|
|
}
|
2018-09-21 13:54:48 +03:00
|
|
|
|
2018-09-21 19:23:46 +03:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-10-06 12:55:16 +03:00
|
|
|
func (b *Bridge) ensureConfig() error {
|
2018-09-21 19:23:46 +03:00
|
|
|
if b.conf == nil {
|
2019-06-17 01:10:21 +03:00
|
|
|
conf, err := loadConfig(b.repo, b.Name)
|
2018-09-21 19:23:46 +03:00
|
|
|
if err != nil {
|
2018-10-06 12:55:16 +03:00
|
|
|
return err
|
2018-09-21 19:23:46 +03:00
|
|
|
}
|
2018-10-06 12:55:16 +03:00
|
|
|
b.conf = conf
|
2018-09-21 19:23:46 +03:00
|
|
|
}
|
|
|
|
|
2018-10-06 12:55:16 +03:00
|
|
|
return nil
|
2018-09-21 19:23:46 +03:00
|
|
|
}
|
|
|
|
|
2019-06-17 01:10:21 +03:00
|
|
|
func loadConfig(repo *cache.RepoCache, name string) (Configuration, error) {
|
|
|
|
keyPrefix := fmt.Sprintf("git-bug.bridge.%s.", name)
|
2018-09-21 19:23:46 +03:00
|
|
|
|
2019-06-17 01:10:21 +03:00
|
|
|
pairs, err := repo.ReadConfigs(keyPrefix)
|
2018-09-21 19:23:46 +03:00
|
|
|
if err != nil {
|
2018-09-24 16:25:15 +03:00
|
|
|
return nil, errors.Wrap(err, "error while reading bridge configuration")
|
2018-09-21 19:23:46 +03:00
|
|
|
}
|
|
|
|
|
2018-09-24 16:25:15 +03:00
|
|
|
result := make(Configuration, len(pairs))
|
|
|
|
for key, value := range pairs {
|
|
|
|
key := strings.TrimPrefix(key, keyPrefix)
|
|
|
|
result[key] = value
|
2018-09-21 19:23:46 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return result, nil
|
|
|
|
}
|
|
|
|
|
2018-10-06 12:55:16 +03:00
|
|
|
func (b *Bridge) getImporter() Importer {
|
|
|
|
if b.importer == nil {
|
|
|
|
b.importer = b.impl.NewImporter()
|
|
|
|
}
|
|
|
|
|
|
|
|
return b.importer
|
|
|
|
}
|
|
|
|
|
|
|
|
func (b *Bridge) getExporter() Exporter {
|
|
|
|
if b.exporter == nil {
|
|
|
|
b.exporter = b.impl.NewExporter()
|
|
|
|
}
|
|
|
|
|
|
|
|
return b.exporter
|
|
|
|
}
|
|
|
|
|
|
|
|
func (b *Bridge) ensureInit() error {
|
|
|
|
if b.initDone {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
importer := b.getImporter()
|
|
|
|
if importer != nil {
|
|
|
|
err := importer.Init(b.conf)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
exporter := b.getExporter()
|
|
|
|
if exporter != nil {
|
|
|
|
err := exporter.Init(b.conf)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
b.initDone = true
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-05-03 01:02:50 +03:00
|
|
|
func (b *Bridge) ImportAll(since time.Time) error {
|
2018-10-06 12:55:16 +03:00
|
|
|
importer := b.getImporter()
|
2018-09-21 19:23:46 +03:00
|
|
|
if importer == nil {
|
2019-02-24 14:56:42 +03:00
|
|
|
return ErrImportNotSupported
|
2018-09-21 19:23:46 +03:00
|
|
|
}
|
|
|
|
|
2018-10-06 12:55:16 +03:00
|
|
|
err := b.ensureConfig()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
err = b.ensureInit()
|
2018-09-21 19:23:46 +03:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-05-03 01:02:50 +03:00
|
|
|
return importer.ImportAll(b.repo, since)
|
2018-09-21 19:23:46 +03:00
|
|
|
}
|
|
|
|
|
2019-06-25 02:33:48 +03:00
|
|
|
func (b *Bridge) ExportAll(since time.Time) (<-chan ExportResult, error) {
|
2018-10-06 12:55:16 +03:00
|
|
|
exporter := b.getExporter()
|
2018-09-21 19:23:46 +03:00
|
|
|
if exporter == nil {
|
2019-06-25 02:33:48 +03:00
|
|
|
return nil, ErrExportNotSupported
|
2018-09-21 19:23:46 +03:00
|
|
|
}
|
|
|
|
|
2018-10-06 12:55:16 +03:00
|
|
|
err := b.ensureConfig()
|
|
|
|
if err != nil {
|
2019-06-25 02:33:48 +03:00
|
|
|
return nil, err
|
2018-10-06 12:55:16 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
err = b.ensureInit()
|
2018-09-21 19:23:46 +03:00
|
|
|
if err != nil {
|
2019-06-25 02:33:48 +03:00
|
|
|
return nil, err
|
2018-09-21 19:23:46 +03:00
|
|
|
}
|
|
|
|
|
2019-07-05 19:32:51 +03:00
|
|
|
return exporter.ExportAll(b.repo, since)
|
2018-09-21 19:23:46 +03:00
|
|
|
}
|