git-bug/bridge/core/bridge.go

318 lines
6.3 KiB
Go
Raw Normal View History

2018-10-01 22:47:12 +03:00
// Package core contains the target-agnostic code to define and run a bridge
package core
import (
"fmt"
2018-09-24 16:25:15 +03:00
"reflect"
"regexp"
2019-06-06 02:05:38 +03:00
"sort"
"strings"
"time"
"github.com/pkg/errors"
"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")
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
// 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
}
// Bridge is a wrapper around a BridgeImpl that will bind low-level
// implementation with utility code to provide high-level functions.
type Bridge struct {
Name string
repo *cache.RepoCache
impl BridgeImpl
importer Importer
exporter Exporter
conf Configuration
initDone bool
}
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,
impl: impl,
}
2018-09-24 16:25:15 +03:00
return bridge, nil
}
// LoadBridge instantiate a new bridge from a repo configuration
func LoadBridge(repo *cache.RepoCache, name string) (*Bridge, error) {
conf, err := loadConfig(repo, name)
2018-09-24 18:11:50 +03:00
if err != nil {
return nil, err
}
target := conf[keyTarget]
bridge, err := NewBridge(repo, target, name)
if err != nil {
return nil, err
}
err = bridge.impl.ValidateConfig(conf)
if err != nil {
return nil, errors.Wrap(err, "invalid configuration")
}
2018-09-24 18:11:50 +03:00
// will avoid reloading configuration before an export or import call
bridge.conf = conf
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
}
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")
}
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
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)
}
if !re.MatchString(name) {
return fmt.Errorf("bad bridge fullname: %s", name)
2018-09-24 16:25:15 +03:00
}
keyPrefix := fmt.Sprintf("git-bug.bridge.%s", name)
2018-09-24 17:24:38 +03:00
return repo.RmConfigs(keyPrefix)
}
2018-10-01 22:47:12 +03:00
// Configure run the target specific configuration process
func (b *Bridge) Configure(params BridgeParams) error {
conf, err := b.impl.Configure(b.repo, params)
if err != nil {
return err
}
err = b.impl.ValidateConfig(conf)
if err != nil {
return fmt.Errorf("invalid configuration: %v", err)
}
2018-09-24 16:25:15 +03:00
b.conf = conf
2018-09-24 16:25:15 +03:00
return b.storeConfig(conf)
}
2018-09-24 16:25:15 +03:00
func (b *Bridge) storeConfig(conf Configuration) error {
for key, val := range conf {
storeKey := fmt.Sprintf("git-bug.bridge.%s.%s", b.Name, key)
2018-09-24 16:25:15 +03:00
err := b.repo.StoreConfig(storeKey, val)
if err != nil {
2018-09-24 16:25:15 +03:00
return errors.Wrap(err, "error while storing bridge configuration")
}
}
return nil
}
func (b *Bridge) ensureConfig() error {
if b.conf == nil {
conf, err := loadConfig(b.repo, b.Name)
if err != nil {
return err
}
b.conf = conf
}
return nil
}
func loadConfig(repo *cache.RepoCache, name string) (Configuration, error) {
keyPrefix := fmt.Sprintf("git-bug.bridge.%s.", name)
pairs, err := repo.ReadConfigs(keyPrefix)
if err != nil {
2018-09-24 16:25:15 +03:00
return nil, errors.Wrap(err, "error while reading bridge configuration")
}
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
}
return result, nil
}
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
}
func (b *Bridge) ImportAll(since time.Time) error {
importer := b.getImporter()
if importer == nil {
2019-02-24 14:56:42 +03:00
return ErrImportNotSupported
}
err := b.ensureConfig()
if err != nil {
return err
}
err = b.ensureInit()
if err != nil {
return err
}
return importer.ImportAll(b.repo, since)
}
func (b *Bridge) ExportAll(since time.Time) (<-chan ExportResult, error) {
exporter := b.getExporter()
if exporter == nil {
return nil, ErrExportNotSupported
}
err := b.ensureConfig()
if err != nil {
return nil, err
}
err = b.ensureInit()
if err != nil {
return nil, err
}
return exporter.ExportAll(b.repo, since)
}