func (s *ProxyUpdaterSuite) TestEnvironmentVariables(c *gc.C) {
setenv := func(proxy, value string) {
os.Setenv(proxy, value)
os.Setenv(strings.ToUpper(proxy), value)
}
setenv("http_proxy", "foo")
setenv("https_proxy", "foo")
setenv("ftp_proxy", "foo")
setenv("no_proxy", "foo")
proxySettings, _ := s.updateConfig(c)
updater, err := proxyupdater.New(s.environmentAPI, true)
c.Assert(err, jc.ErrorIsNil)
defer worker.Stop(updater)
s.waitForPostSetup(c)
s.waitProxySettings(c, proxySettings)
assertEnv := func(proxy, value string) {
c.Assert(os.Getenv(proxy), gc.Equals, value)
c.Assert(os.Getenv(strings.ToUpper(proxy)), gc.Equals, value)
}
assertEnv("http_proxy", proxySettings.Http)
assertEnv("https_proxy", proxySettings.Https)
assertEnv("ftp_proxy", proxySettings.Ftp)
assertEnv("no_proxy", proxySettings.NoProxy)
}
func (s *ProxyUpdaterSuite) TestDontWriteSystemFiles(c *gc.C) {
proxySettings, _ := s.updateConfig(c)
updater := proxyupdater.New(s.environmentAPI, false)
defer worker.Stop(updater)
s.waitForPostSetup(c)
s.waitProxySettings(c, proxySettings)
c.Assert(pacconfig.AptProxyConfigFile, jc.DoesNotExist)
c.Assert(s.proxyFile, jc.DoesNotExist)
}
func (s *ProxyUpdaterSuite) TestInitialState(c *gc.C) {
proxySettings, aptProxySettings := s.updateConfig(c)
updater := proxyupdater.New(s.environmentAPI, true)
defer worker.Stop(updater)
s.waitProxySettings(c, proxySettings)
s.waitForFile(c, s.proxyFile, proxySettings.AsScriptEnvironment()+"\n")
paccmder, err := commands.NewPackageCommander(version.Current.Series)
c.Assert(err, jc.ErrorIsNil)
s.waitForFile(c, pacconfig.AptProxyConfigFile, paccmder.ProxyConfigContents(aptProxySettings)+"\n")
}
func (s *ProxyUpdaterSuite) TestWriteSystemFiles(c *gc.C) {
proxySettings, aptProxySettings := s.updateConfig(c)
updater := proxyupdater.New(s.environmentAPI, true)
defer worker.Stop(updater)
s.waitForPostSetup(c)
s.waitProxySettings(c, proxySettings)
s.waitForFile(c, s.proxyFile, proxySettings.AsScriptEnvironment()+"\n")
paccmder, err := commands.NewPackageCommander(series.HostSeries())
c.Assert(err, jc.ErrorIsNil)
s.waitForFile(c, pacconfig.AptProxyConfigFile, paccmder.ProxyConfigContents(aptProxySettings)+"\n")
}
func (a *UnitAgent) APIWorkers() (_ worker.Worker, err error) {
agentConfig := a.CurrentConfig()
dataDir := agentConfig.DataDir()
hookLock, err := cmdutil.HookExecutionLock(dataDir)
if err != nil {
return nil, err
}
st, entity, err := OpenAPIState(agentConfig, a)
if err != nil {
return nil, err
}
unitTag, err := names.ParseUnitTag(entity.Tag())
if err != nil {
return nil, errors.Trace(err)
}
// Ensure that the environment uuid is stored in the agent config.
// Luckily the API has it recorded for us after we connect.
if agentConfig.Environment().Id() == "" {
err := a.ChangeConfig(func(setter agent.ConfigSetter) error {
environTag, err := st.EnvironTag()
if err != nil {
return errors.Annotate(err, "no environment uuid set on api")
}
return setter.Migrate(agent.MigrateParams{
Environment: environTag,
})
})
if err != nil {
logger.Warningf("unable to save environment uuid: %v", err)
// Not really fatal, just annoying.
}
}
defer func() {
if err != nil {
st.Close()
reportClosedUnitAPI(st)
}
}()
// Before starting any workers, ensure we record the Juju version this unit
// agent is running.
currentTools := &tools.Tools{Version: version.Current}
apiStateUpgrader := a.getUpgrader(st)
if err := apiStateUpgrader.SetVersion(agentConfig.Tag().String(), currentTools.Version); err != nil {
return nil, errors.Annotate(err, "cannot set unit agent version")
}
runner := worker.NewRunner(cmdutil.ConnectionIsFatal(logger, st), cmdutil.MoreImportant)
// start proxyupdater first to ensure proxy settings are correct
runner.StartWorker("proxyupdater", func() (worker.Worker, error) {
return proxyupdater.New(st.Environment(), false), nil
})
runner.StartWorker("upgrader", func() (worker.Worker, error) {
return upgrader.NewAgentUpgrader(
st.Upgrader(),
agentConfig,
agentConfig.UpgradedToVersion(),
func() bool { return false },
a.initialAgentUpgradeCheckComplete,
), nil
})
runner.StartWorker("logger", func() (worker.Worker, error) {
return workerlogger.NewLogger(st.Logger(), agentConfig), nil
})
runner.StartWorker("uniter", func() (worker.Worker, error) {
uniterFacade, err := st.Uniter()
if err != nil {
return nil, errors.Trace(err)
}
uniterParams := uniter.UniterParams{
uniterFacade,
unitTag,
leadership.NewClient(st),
dataDir,
hookLock,
uniter.NewMetricsTimerChooser(),
uniter.NewUpdateStatusTimer(),
}
return uniter.NewUniter(&uniterParams), nil
})
runner.StartWorker("apiaddressupdater", func() (worker.Worker, error) {
uniterFacade, err := st.Uniter()
if err != nil {
return nil, errors.Trace(err)
}
return apiaddressupdater.NewAPIAddressUpdater(uniterFacade, a), nil
})
runner.StartWorker("rsyslog", func() (worker.Worker, error) {
return cmdutil.NewRsyslogConfigWorker(st.Rsyslog(), agentConfig, rsyslog.RsyslogModeForwarding)
})
return cmdutil.NewCloseWorker(logger, runner, st), nil
}
func (s *ProxyUpdaterSuite) TestRunStop(c *gc.C) {
updater, err := proxyupdater.New(s.environmentAPI, false)
c.Assert(err, jc.ErrorIsNil)
err = worker.Stop(updater)
c.Assert(err, jc.ErrorIsNil)
}
func (s *ProxyUpdaterSuite) TestRunStop(c *gc.C) {
updater := proxyupdater.New(s.environmentAPI, false)
c.Assert(worker.Stop(updater), gc.IsNil)
}