func initInstallCommand(flags *flag.FlagSet, installer, defaultDBPath, defaultProfilesPath string) {
initCommon(flags, &installFlags.commonFlagValues, installer, defaultDBPath, defaultProfilesPath)
profiles.RegisterTargetAndEnvFlags(flags, &installFlags.target)
flags.BoolVar(&installFlags.force, "force", false, "force install the profile even if it is already installed")
for _, name := range profilesmanager.Managers() {
profilesmanager.LookupManager(name).AddFlags(flags, profiles.Install)
}
}
// RegisterReaderFlags registers the 'reader' flags (see below)
// with the parent command. The values of the flags can be accessed via
// the supplied ReaderFlagValues struct.
// The reader flags are:
// --skip-profiles
// --profiles-db
// --profiles
// --merge-policies
// --target and --env
func RegisterReaderFlags(flags *flag.FlagSet, fv *ReaderFlagValues, defaultProfiles, defaultDBPath string) {
flags.Var(&fv.ProfilesMode, "skip-profiles", "if set, no profiles will be used")
RegisterDBPathFlag(flags, &fv.DBFilename, defaultDBPath)
RegisterProfilesFlag(flags, defaultProfiles, &fv.Profiles)
fv.MergePolicies = profilesreader.JiriMergePolicies()
RegisterMergePoliciesFlag(flags, &fv.MergePolicies)
profiles.RegisterTargetAndEnvFlags(flags, &fv.Target)
}
func initPackagesCommand(flags *flag.FlagSet, installer, defaultDBPath, defaultProfilesPath string) {
initCommon(flags, &packagesFlags.commonFlagValues, installer, defaultDBPath, defaultProfilesPath)
profiles.RegisterTargetAndEnvFlags(flags, &packagesFlags.target)
flags.BoolVar(&packagesFlags.allPackages, "all", false, "print commands to install all required OS packages, not just those that are missing")
flags.BoolVar(&packagesFlags.installPackages, "install", false, "install the requested packages. This may need to be run as root.")
for _, name := range profilesmanager.Managers() {
profilesmanager.LookupManager(name).AddFlags(flags, profiles.Install)
}
}
func ExampleProfileTarget() {
var target profiles.Target
flags := flag.NewFlagSet("test", flag.ContinueOnError)
profiles.RegisterTargetAndEnvFlags(flags, &target)
flags.Parse([]string{"--target=arm-linux", "--env=A=B,C=D", "--env=E=F"})
fmt.Println(target.String())
fmt.Println(target.DebugString())
// Output:
// arm-linux@
// arm-linux@ dir: --env=A=B,C=D,E=F envvars:[]
}
func Init(defaultManifestFilename string) {
targetFlag = profiles.DefaultTarget()
var err error
rootDir, err = project.JiriRoot()
if err != nil {
panic(err)
}
manifest := filepath.Join(rootDir, defaultManifestFilename)
// Every sub-command accepts: --manifest
for _, fs := range []*flag.FlagSet{
&cmdInstall.Flags,
&cmdUpdate.Flags,
&cmdCleanup.Flags,
&cmdUninstall.Flags,
&cmdEnv.Flags,
&cmdList.Flags,
&cmdRecreate.Flags} {
profiles.RegisterManifestFlag(fs, &manifestFlag, manifest)
}
// install accepts: --target and, --env.
profiles.RegisterTargetAndEnvFlags(&cmdInstall.Flags, &targetFlag)
// uninstall and env accept: --target,
for _, fs := range []*flag.FlagSet{
&cmdUninstall.Flags,
&cmdEnv.Flags} {
profiles.RegisterTargetFlag(fs, &targetFlag)
}
// uninstall accept --all-targets but with different defaults.
cmdUninstall.Flags.BoolVar(&allFlag, "all-targets", false, "apply to all targets for the specified profile(s)")
// update accepts --v
cmdUpdate.Flags.BoolVar(&verboseFlag, "v", false, "print more detailed information")
// list accepts --show-manifest, --availabe, --v
cmdList.Flags.BoolVar(&showManifestFlag, "show-manifest", false, "print out the manifest file")
cmdList.Flags.BoolVar(&availableFlag, "available", false, "print the list of available profiles")
cmdList.Flags.BoolVar(&verboseFlag, "v", false, "print more detailed information")
// env accepts --profile
cmdEnv.Flags.StringVar(&profileFlag, "profile", "", "the profile whose environment is to be displayed")
for _, mgr := range profiles.Managers() {
profiles.LookupManager(mgr).AddFlags(&cmdInstall.Flags, profiles.Install)
profiles.LookupManager(mgr).AddFlags(&cmdUninstall.Flags, profiles.Uninstall)
}
}
func ExampleManager() {
myProfile := "myNewProfile"
var target profiles.Target
init := func() {
profiles.Register(myProfile, newProfile(myProfile))
flags := flag.NewFlagSet("example", flag.ContinueOnError)
profiles.RegisterTargetAndEnvFlags(flags, &target)
flags.Parse([]string{"--target=myTarget=arm-linux", "--env=A=B,C=D", "--env=E=F"})
}
init()
mgr := profiles.LookupManager(myProfile)
if mgr == nil {
panic("manager not found for: " + myProfile)
}
ctx := tool.NewDefaultContext()
// Install myNewProfile for target.
if err := mgr.Install(ctx, target); err != nil {
panic("failed to find manager for: " + myProfile)
}
fmt.Println(mgr.String())
filename := tmpFile()
defer os.RemoveAll(filepath.Dir(filename))
if err := profiles.Write(ctx, filename); err != nil {
panic(err)
}
// Clear the profile manifest information in order to mimic starting
// a new process and reading the manifest file.
profiles.Clear()
// Read the profile manifest.
profiles.Read(ctx, filename)
mgr = profiles.LookupManager(myProfile)
if mgr == nil {
panic("manager not found for: " + myProfile)
}
fmt.Println(mgr.String())
mgr.Uninstall(ctx, target)
fmt.Println(mgr.String())
fmt.Println(mgr.VersionInfo().Supported())
fmt.Println(mgr.VersionInfo().Default())
// Output:
// Profile: myNewProfile: installed
// [myTarget=arm-linux@]
//
// Profile: myNewProfile: installed
// [myTarget=arm-linux@]
//
// Profile: myNewProfile: uninstalled
//
// [4 3 2]
// 3
}
func ExampleManager() {
pdb := profiles.NewDB()
myInstaller := "myProject"
myProfile := "myNewProfile"
profileName := profiles.QualifiedProfileName(myInstaller, myProfile)
var target profiles.Target
init := func() {
mgr := newProfileMgr(myInstaller, myProfile)
profilesmanager.Register(mgr)
flags := flag.NewFlagSet("example", flag.ContinueOnError)
profiles.RegisterTargetAndEnvFlags(flags, &target)
flags.Parse([]string{"--target=arm-linux@1", "--env=A=B,C=D", "--env=E=F"})
}
init()
profileRoot := jiri.NewRelPath("profiles")
mgr := profilesmanager.LookupManager(profileName)
if mgr == nil {
panic("manager not found for: " + profileName)
}
jirix := &jiri.X{Context: tool.NewDefaultContext()}
// Install myNewProfile for target.
if err := mgr.Install(jirix, pdb, profileRoot, target); err != nil {
panic("failed to find manager for: " + profileName)
}
fmt.Println(mgr.String())
filename := tmpFile()
defer os.RemoveAll(filepath.Dir(filename))
if err := pdb.Write(jirix, "test", filename); err != nil {
panic(err)
}
// Start with a new profile data base.
pdb = profiles.NewDB()
// Read the profile database.
pdb.Read(jirix, filename)
mgr = profilesmanager.LookupManager(profileName)
if mgr == nil {
panic("manager not found for: " + profileName)
}
fmt.Println(mgr.String())
mgr.Uninstall(jirix, pdb, profileRoot, target)
fmt.Println(mgr.String())
fmt.Println(mgr.VersionInfo().Supported())
fmt.Println(mgr.VersionInfo().Default())
// Output:
// Profile: myNewProfile: installed
// [arm-linux@1]
//
// Profile: myNewProfile: installed
// [arm-linux@1]
//
// Profile: myNewProfile: not installed
//
// [4 3 2]
// 3
}
