// NewContextFactory returns a ContextFactory capable of creating execution contexts backed
// by the supplied unit's supplied API connection.
func NewContextFactory(
state *uniter.State,
unitTag names.UnitTag,
tracker leadership.Tracker,
getRelationInfos RelationsFunc,
storage StorageContextAccessor,
paths Paths,
clock clock.Clock,
) (
ContextFactory, error,
) {
unit, err := state.Unit(unitTag)
if err != nil {
return nil, errors.Trace(err)
}
machineTag, err := unit.AssignedMachine()
if err != nil {
return nil, errors.Trace(err)
}
model, err := state.Model()
if err != nil {
return nil, errors.Trace(err)
}
zone, err := unit.AvailabilityZone()
if err != nil {
return nil, errors.Trace(err)
}
f := &contextFactory{
unit: unit,
state: state,
tracker: tracker,
paths: paths,
modelUUID: model.UUID(),
envName: model.Name(),
machineTag: machineTag,
getRelationInfos: getRelationInfos,
relationCaches: map[int]*RelationCache{},
storage: storage,
rand: rand.New(rand.NewSource(time.Now().Unix())),
clock: clock,
zone: zone,
}
return f, nil
}
// NewRelations returns a new Relations instance.
func NewRelations(st *uniter.State, tag names.UnitTag, charmDir, relationsDir string, abort <-chan struct{}) (Relations, error) {
unit, err := st.Unit(tag)
if err != nil {
return nil, errors.Trace(err)
}
r := &relations{
st: st,
unit: unit,
charmDir: charmDir,
relationsDir: relationsDir,
relationers: make(map[int]*Relationer),
abort: abort,
}
if err := r.init(); err != nil {
return nil, errors.Trace(err)
}
return r, nil
}
func newRelations(st *uniter.State, tag names.UnitTag, paths Paths, abort <-chan struct{}) (*relations, error) {
unit, err := st.Unit(tag)
if err != nil {
return nil, errors.Trace(err)
}
r := &relations{
st: st,
unit: unit,
charmDir: paths.State.CharmDir,
relationsDir: paths.State.RelationsDir,
relationers: make(map[int]*Relationer),
relationHooks: make(chan hook.Info),
abort: abort,
}
if err := r.init(); err != nil {
return nil, errors.Trace(err)
}
return r, nil
}
// NewContextFactory returns a ContextFactory capable of creating execution contexts backed
// by the supplied unit's supplied API connection.
func NewContextFactory(
state *uniter.State,
unitTag names.UnitTag,
tracker leadership.Tracker,
getRelationInfos RelationsFunc,
storage StorageContextAccessor,
paths Paths,
) (
ContextFactory, error,
) {
unit, err := state.Unit(unitTag)
if err != nil {
return nil, errors.Trace(err)
}
machineTag, err := unit.AssignedMachine()
if err != nil {
return nil, errors.Trace(err)
}
environment, err := state.Environment()
if err != nil {
return nil, errors.Trace(err)
}
f := &contextFactory{
unit: unit,
state: state,
tracker: tracker,
paths: paths,
envUUID: environment.UUID(),
envName: environment.Name(),
machineTag: machineTag,
getRelationInfos: getRelationInfos,
relationCaches: map[int]*RelationCache{},
storage: storage,
rand: rand.New(rand.NewSource(time.Now().Unix())),
}
return f, nil
}
func NewHookContext(
unit *uniter.Unit,
state *uniter.State,
id,
uuid,
envName string,
relationId int,
remoteUnitName string,
relations map[int]*ContextRelation,
apiAddrs []string,
serviceOwner names.UserTag,
proxySettings proxy.Settings,
canAddMetrics bool,
metrics *charm.Metrics,
actionData *ActionData,
assignedMachineTag names.MachineTag,
paths Paths,
) (*HookContext, error) {
ctx := &HookContext{
unit: unit,
state: state,
id: id,
uuid: uuid,
envName: envName,
unitName: unit.Name(),
relationId: relationId,
remoteUnitName: remoteUnitName,
relations: relations,
apiAddrs: apiAddrs,
serviceOwner: serviceOwner,
proxySettings: proxySettings,
metricsRecorder: nil,
definedMetrics: metrics,
metricsSender: unit,
actionData: actionData,
pendingPorts: make(map[PortRange]PortRangeInfo),
assignedMachineTag: assignedMachineTag,
}
if canAddMetrics {
charmURL, err := unit.CharmURL()
if err != nil {
return nil, err
}
ctx.metricsRecorder, err = NewJSONMetricsRecorder(paths.GetMetricsSpoolDir(), charmURL.String())
if err != nil {
return nil, err
}
ctx.metricsReader, err = NewJSONMetricsReader(paths.GetMetricsSpoolDir())
if err != nil {
return nil, err
}
}
// Get and cache the addresses.
var err error
ctx.publicAddress, err = unit.PublicAddress()
if err != nil && !params.IsCodeNoAddressSet(err) {
return nil, err
}
ctx.privateAddress, err = unit.PrivateAddress()
if err != nil && !params.IsCodeNoAddressSet(err) {
return nil, err
}
ctx.availabilityzone, err = unit.AvailabilityZone()
if err != nil {
return nil, err
}
ctx.machinePorts, err = state.AllMachinePorts(ctx.assignedMachineTag)
if err != nil {
return nil, errors.Trace(err)
}
statusCode, statusInfo, err := unit.MeterStatus()
if err != nil {
return nil, errors.Annotate(err, "could not retrieve meter status for unit")
}
ctx.meterStatus = &meterStatus{
code: statusCode,
info: statusInfo,
}
return ctx, nil
}