// NewRepository create a new Repository with name and from url.
func NewRepository(name, url, cachedir string, backends []string, setupBackend, checkForUpdates bool) (*Repository, error) {
repo := Repository{
msg: logger.NewLogger("repo", logger.INFO, os.Stdout),
Name: name,
RepoUrl: url,
RepoMdUrl: url + "/repodata/repomd.xml",
LocalRepoMdXml: filepath.Join(cachedir, "repomd.xml"),
CacheDir: cachedir,
Backends: make([]string, len(backends)),
}
copy(repo.Backends, backends)
err := os.MkdirAll(cachedir, 0644)
if err != nil {
return nil, err
}
// load appropriate backend if requested
if setupBackend {
if checkForUpdates {
err = repo.setupBackendFromRemote()
if err != nil {
return nil, err
}
} else {
err = repo.setupBackendFromLocal()
if err != nil {
return nil, err
}
}
}
return &repo, err
}
// newClient returns a Client from siteroot and backends.
// manualConfig is just for internal tests
func newClient(siteroot string, backends []string, checkForUpdates, manualConfig bool) (*Client, error) {
client := &Client{
msg: logger.NewLogger("yum", logger.INFO, os.Stdout),
siteroot: siteroot,
etcdir: filepath.Join(siteroot, "etc"),
lbyumcache: filepath.Join(siteroot, "var", "cache", "lbyum"),
yumconf: filepath.Join(siteroot, "etc", "yum.conf"),
yumreposdir: filepath.Join(siteroot, "etc", "yum.repos.d"),
configured: false,
repos: make(map[string]*Repository),
repourls: make(map[string]string),
}
if manualConfig {
return client, nil
}
// load the config and set the URLs accordingly
urls, err := client.loadConfig()
if err != nil {
client.msg.Errorf("could not load yum config: %v\n", err)
return nil, err
}
// At this point we have the repo names and URLs in self.repourls
// we know connect to them to get the best method to get the appropriate files
err = client.initRepositories(urls, checkForUpdates, backends)
if err != nil {
client.msg.Errorf("could not initialize repositories: %v\n", err)
return nil, err
}
return client, err
}
func New(cfg Config, options ...func(*Context)) (*Context, error) {
var err error
siteroot := cfg.Siteroot()
if siteroot == "" {
siteroot = "/opt/cern-sw"
}
ctx := Context{
cfg: cfg,
msg: logger.NewLogger("lbpkr", logger.INFO, os.Stdout),
siteroot: siteroot,
repourl: cfg.RepoUrl(),
dbpath: filepath.Join(siteroot, "var", "lib", "rpm"),
etcdir: filepath.Join(siteroot, "etc"),
yumconf: filepath.Join(siteroot, "etc", "yum.conf"),
yumreposd: filepath.Join(siteroot, "etc", "yum.repos.d"),
tmpdir: filepath.Join(siteroot, "tmp"),
bindir: filepath.Join(siteroot, "usr", "bin"),
libdir: filepath.Join(siteroot, "lib"),
initfile: filepath.Join(siteroot, "etc", "repoinit"),
installdb: nil,
ndls: runtime.NumCPU(),
sigch: make(chan os.Signal),
subcmds: make([]*exec.Cmd, 0),
atexit: make([]func(), 0),
}
for _, opt := range options {
opt(&ctx)
}
for _, dir := range []string{
siteroot,
ctx.dbpath,
ctx.etcdir,
ctx.yumreposd,
ctx.tmpdir,
ctx.bindir,
ctx.libdir,
} {
err = os.MkdirAll(dir, 0755)
if err != nil {
ctx.msg.Errorf("could not create directory %q: %v\n", dir, err)
return nil, err
}
}
os.Setenv("PATH", os.Getenv("PATH")+string(os.PathListSeparator)+ctx.bindir)
ctx.initSignalHandler()
// make sure the db is initialized
err = ctx.initRpmDb()
if err != nil {
return nil, err
}
// yum
err = ctx.initYum()
if err != nil {
return nil, err
}
ctx.yum, err = yum.New(ctx.siteroot)
if err != nil {
return nil, err
}
if ctx.msg.Level() < logger.INFO {
ctx.yum.SetLevel(logger.DEBUG)
}
// defining structures and checking if all needed tools are available
ctx.extstatus = make(map[string]External)
ctx.reqext = []string{"rpm"}
ctx.extfix = make(map[string]FixFct)
err = ctx.checkPreRequisites()
if err != nil {
return nil, err
}
err = ctx.checkRepository()
if err != nil {
return nil, err
}
return &ctx, err
}