id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
155,500 | juju/juju | state/multiwatcher.go | seen | func (sm *storeManager) seen(revno int64) {
for e := sm.all.list.Front(); e != nil; {
next := e.Next()
entry := e.Value.(*entityEntry)
if entry.revno <= revno {
break
}
if entry.creationRevno > revno {
if !entry.removed {
// This is a new entity that hasn't been seen yet,
// so increment the entry's refCount.
entry.refCount++
}
} else if entry.removed {
// This is an entity that we previously saw, but
// has now been removed, so decrement its refCount, removing
// the entity if nothing else is waiting to be notified that it's
// gone.
sm.all.decRef(entry)
}
e = next
}
} | go | func (sm *storeManager) seen(revno int64) {
for e := sm.all.list.Front(); e != nil; {
next := e.Next()
entry := e.Value.(*entityEntry)
if entry.revno <= revno {
break
}
if entry.creationRevno > revno {
if !entry.removed {
// This is a new entity that hasn't been seen yet,
// so increment the entry's refCount.
entry.refCount++
}
} else if entry.removed {
// This is an entity that we previously saw, but
// has now been removed, so decrement its refCount, removing
// the entity if nothing else is waiting to be notified that it's
// gone.
sm.all.decRef(entry)
}
e = next
}
} | [
"func",
"(",
"sm",
"*",
"storeManager",
")",
"seen",
"(",
"revno",
"int64",
")",
"{",
"for",
"e",
":=",
"sm",
".",
"all",
".",
"list",
".",
"Front",
"(",
")",
";",
"e",
"!=",
"nil",
";",
"{",
"next",
":=",
"e",
".",
"Next",
"(",
")",
"\n",
... | // seen states that a Multiwatcher has just been given information about
// all entities newer than the given revno. We assume it has already
// seen all the older entities. | [
"seen",
"states",
"that",
"a",
"Multiwatcher",
"has",
"just",
"been",
"given",
"information",
"about",
"all",
"entities",
"newer",
"than",
"the",
"given",
"revno",
".",
"We",
"assume",
"it",
"has",
"already",
"seen",
"all",
"the",
"older",
"entities",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/multiwatcher.go#L328-L350 |
155,501 | juju/juju | state/multiwatcher.go | leave | func (sm *storeManager) leave(w *Multiwatcher) {
for e := sm.all.list.Front(); e != nil; {
next := e.Next()
entry := e.Value.(*entityEntry)
if entry.creationRevno <= w.revno {
// The watcher has seen this entry.
if entry.removed && entry.revno <= w.revno {
// The entity has been removed and the
// watcher has already been informed of that,
// so its refcount has already been decremented.
e = next
continue
}
sm.all.decRef(entry)
}
e = next
}
} | go | func (sm *storeManager) leave(w *Multiwatcher) {
for e := sm.all.list.Front(); e != nil; {
next := e.Next()
entry := e.Value.(*entityEntry)
if entry.creationRevno <= w.revno {
// The watcher has seen this entry.
if entry.removed && entry.revno <= w.revno {
// The entity has been removed and the
// watcher has already been informed of that,
// so its refcount has already been decremented.
e = next
continue
}
sm.all.decRef(entry)
}
e = next
}
} | [
"func",
"(",
"sm",
"*",
"storeManager",
")",
"leave",
"(",
"w",
"*",
"Multiwatcher",
")",
"{",
"for",
"e",
":=",
"sm",
".",
"all",
".",
"list",
".",
"Front",
"(",
")",
";",
"e",
"!=",
"nil",
";",
"{",
"next",
":=",
"e",
".",
"Next",
"(",
")",... | // leave is called when the given watcher leaves. It decrements the reference
// counts of any entities that have been seen by the watcher. | [
"leave",
"is",
"called",
"when",
"the",
"given",
"watcher",
"leaves",
".",
"It",
"decrements",
"the",
"reference",
"counts",
"of",
"any",
"entities",
"that",
"have",
"been",
"seen",
"by",
"the",
"watcher",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/multiwatcher.go#L354-L371 |
155,502 | juju/juju | state/multiwatcher.go | newStore | func newStore() *multiwatcherStore {
return &multiwatcherStore{
entities: make(map[interface{}]*list.Element),
list: list.New(),
}
} | go | func newStore() *multiwatcherStore {
return &multiwatcherStore{
entities: make(map[interface{}]*list.Element),
list: list.New(),
}
} | [
"func",
"newStore",
"(",
")",
"*",
"multiwatcherStore",
"{",
"return",
"&",
"multiwatcherStore",
"{",
"entities",
":",
"make",
"(",
"map",
"[",
"interface",
"{",
"}",
"]",
"*",
"list",
".",
"Element",
")",
",",
"list",
":",
"list",
".",
"New",
"(",
"... | // newStore returns an Store instance holding information about the
// current state of all entities in the model.
// It is only exposed here for testing purposes. | [
"newStore",
"returns",
"an",
"Store",
"instance",
"holding",
"information",
"about",
"the",
"current",
"state",
"of",
"all",
"entities",
"in",
"the",
"model",
".",
"It",
"is",
"only",
"exposed",
"here",
"for",
"testing",
"purposes",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/multiwatcher.go#L413-L418 |
155,503 | juju/juju | state/multiwatcher.go | All | func (a *multiwatcherStore) All() []multiwatcher.EntityInfo {
entities := make([]multiwatcher.EntityInfo, 0, a.list.Len())
for e := a.list.Front(); e != nil; e = e.Next() {
entry := e.Value.(*entityEntry)
if entry.removed {
continue
}
entities = append(entities, entry.info)
}
return entities
} | go | func (a *multiwatcherStore) All() []multiwatcher.EntityInfo {
entities := make([]multiwatcher.EntityInfo, 0, a.list.Len())
for e := a.list.Front(); e != nil; e = e.Next() {
entry := e.Value.(*entityEntry)
if entry.removed {
continue
}
entities = append(entities, entry.info)
}
return entities
} | [
"func",
"(",
"a",
"*",
"multiwatcherStore",
")",
"All",
"(",
")",
"[",
"]",
"multiwatcher",
".",
"EntityInfo",
"{",
"entities",
":=",
"make",
"(",
"[",
"]",
"multiwatcher",
".",
"EntityInfo",
",",
"0",
",",
"a",
".",
"list",
".",
"Len",
"(",
")",
"... | // All returns all the entities stored in the Store,
// oldest first. It is only exposed for testing purposes. | [
"All",
"returns",
"all",
"the",
"entities",
"stored",
"in",
"the",
"Store",
"oldest",
"first",
".",
"It",
"is",
"only",
"exposed",
"for",
"testing",
"purposes",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/multiwatcher.go#L422-L432 |
155,504 | juju/juju | state/multiwatcher.go | add | func (a *multiwatcherStore) add(id interface{}, info multiwatcher.EntityInfo) {
if _, ok := a.entities[id]; ok {
panic("adding new entry with duplicate id")
}
a.latestRevno++
entry := &entityEntry{
info: info,
revno: a.latestRevno,
creationRevno: a.latestRevno,
}
a.entities[id] = a.list.PushFront(entry)
} | go | func (a *multiwatcherStore) add(id interface{}, info multiwatcher.EntityInfo) {
if _, ok := a.entities[id]; ok {
panic("adding new entry with duplicate id")
}
a.latestRevno++
entry := &entityEntry{
info: info,
revno: a.latestRevno,
creationRevno: a.latestRevno,
}
a.entities[id] = a.list.PushFront(entry)
} | [
"func",
"(",
"a",
"*",
"multiwatcherStore",
")",
"add",
"(",
"id",
"interface",
"{",
"}",
",",
"info",
"multiwatcher",
".",
"EntityInfo",
")",
"{",
"if",
"_",
",",
"ok",
":=",
"a",
".",
"entities",
"[",
"id",
"]",
";",
"ok",
"{",
"panic",
"(",
"\... | // add adds a new entity with the given id and associated
// information to the list. | [
"add",
"adds",
"a",
"new",
"entity",
"with",
"the",
"given",
"id",
"and",
"associated",
"information",
"to",
"the",
"list",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/multiwatcher.go#L436-L447 |
155,505 | juju/juju | state/multiwatcher.go | decRef | func (a *multiwatcherStore) decRef(entry *entityEntry) {
if entry.refCount--; entry.refCount > 0 {
return
}
if entry.refCount < 0 {
panic("negative reference count")
}
if !entry.removed {
return
}
id := entry.info.EntityId()
elem, ok := a.entities[id]
if !ok {
panic("delete of non-existent entry")
}
delete(a.entities, id)
a.list.Remove(elem)
} | go | func (a *multiwatcherStore) decRef(entry *entityEntry) {
if entry.refCount--; entry.refCount > 0 {
return
}
if entry.refCount < 0 {
panic("negative reference count")
}
if !entry.removed {
return
}
id := entry.info.EntityId()
elem, ok := a.entities[id]
if !ok {
panic("delete of non-existent entry")
}
delete(a.entities, id)
a.list.Remove(elem)
} | [
"func",
"(",
"a",
"*",
"multiwatcherStore",
")",
"decRef",
"(",
"entry",
"*",
"entityEntry",
")",
"{",
"if",
"entry",
".",
"refCount",
"--",
";",
"entry",
".",
"refCount",
">",
"0",
"{",
"return",
"\n",
"}",
"\n",
"if",
"entry",
".",
"refCount",
"<",... | // decRef decrements the reference count of an entry within the list,
// deleting it if it becomes zero and the entry is removed. | [
"decRef",
"decrements",
"the",
"reference",
"count",
"of",
"an",
"entry",
"within",
"the",
"list",
"deleting",
"it",
"if",
"it",
"becomes",
"zero",
"and",
"the",
"entry",
"is",
"removed",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/multiwatcher.go#L451-L468 |
155,506 | juju/juju | state/multiwatcher.go | delete | func (a *multiwatcherStore) delete(id multiwatcher.EntityId) {
elem, ok := a.entities[id]
if !ok {
return
}
delete(a.entities, id)
a.list.Remove(elem)
} | go | func (a *multiwatcherStore) delete(id multiwatcher.EntityId) {
elem, ok := a.entities[id]
if !ok {
return
}
delete(a.entities, id)
a.list.Remove(elem)
} | [
"func",
"(",
"a",
"*",
"multiwatcherStore",
")",
"delete",
"(",
"id",
"multiwatcher",
".",
"EntityId",
")",
"{",
"elem",
",",
"ok",
":=",
"a",
".",
"entities",
"[",
"id",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\n",
"}",
"\n",
"delete",
"(",
... | // delete deletes the entry with the given info id. | [
"delete",
"deletes",
"the",
"entry",
"with",
"the",
"given",
"info",
"id",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/multiwatcher.go#L471-L478 |
155,507 | juju/juju | state/multiwatcher.go | Remove | func (a *multiwatcherStore) Remove(id multiwatcher.EntityId) {
if elem := a.entities[id]; elem != nil {
entry := elem.Value.(*entityEntry)
if entry.removed {
return
}
a.latestRevno++
if entry.refCount == 0 {
a.delete(id)
return
}
entry.revno = a.latestRevno
entry.removed = true
a.list.MoveToFront(elem)
}
} | go | func (a *multiwatcherStore) Remove(id multiwatcher.EntityId) {
if elem := a.entities[id]; elem != nil {
entry := elem.Value.(*entityEntry)
if entry.removed {
return
}
a.latestRevno++
if entry.refCount == 0 {
a.delete(id)
return
}
entry.revno = a.latestRevno
entry.removed = true
a.list.MoveToFront(elem)
}
} | [
"func",
"(",
"a",
"*",
"multiwatcherStore",
")",
"Remove",
"(",
"id",
"multiwatcher",
".",
"EntityId",
")",
"{",
"if",
"elem",
":=",
"a",
".",
"entities",
"[",
"id",
"]",
";",
"elem",
"!=",
"nil",
"{",
"entry",
":=",
"elem",
".",
"Value",
".",
"(",... | // Remove marks that the entity with the given id has
// been removed from the backing. If nothing has seen the
// entity, then we delete it immediately. | [
"Remove",
"marks",
"that",
"the",
"entity",
"with",
"the",
"given",
"id",
"has",
"been",
"removed",
"from",
"the",
"backing",
".",
"If",
"nothing",
"has",
"seen",
"the",
"entity",
"then",
"we",
"delete",
"it",
"immediately",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/multiwatcher.go#L483-L498 |
155,508 | juju/juju | state/multiwatcher.go | Update | func (a *multiwatcherStore) Update(info multiwatcher.EntityInfo) {
id := info.EntityId()
elem, ok := a.entities[id]
if !ok {
a.add(id, info)
return
}
entry := elem.Value.(*entityEntry)
// Nothing has changed, so change nothing.
// TODO(rog) do the comparison more efficiently.
if reflect.DeepEqual(info, entry.info) {
return
}
// We already know about the entity; update its doc.
a.latestRevno++
entry.revno = a.latestRevno
entry.info = info
// The app might have been removed and re-added.
entry.removed = false
a.list.MoveToFront(elem)
} | go | func (a *multiwatcherStore) Update(info multiwatcher.EntityInfo) {
id := info.EntityId()
elem, ok := a.entities[id]
if !ok {
a.add(id, info)
return
}
entry := elem.Value.(*entityEntry)
// Nothing has changed, so change nothing.
// TODO(rog) do the comparison more efficiently.
if reflect.DeepEqual(info, entry.info) {
return
}
// We already know about the entity; update its doc.
a.latestRevno++
entry.revno = a.latestRevno
entry.info = info
// The app might have been removed and re-added.
entry.removed = false
a.list.MoveToFront(elem)
} | [
"func",
"(",
"a",
"*",
"multiwatcherStore",
")",
"Update",
"(",
"info",
"multiwatcher",
".",
"EntityInfo",
")",
"{",
"id",
":=",
"info",
".",
"EntityId",
"(",
")",
"\n",
"elem",
",",
"ok",
":=",
"a",
".",
"entities",
"[",
"id",
"]",
"\n",
"if",
"!"... | // Update updates the information for the given entity. | [
"Update",
"updates",
"the",
"information",
"for",
"the",
"given",
"entity",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/multiwatcher.go#L501-L521 |
155,509 | juju/juju | state/multiwatcher.go | Get | func (a *multiwatcherStore) Get(id multiwatcher.EntityId) multiwatcher.EntityInfo {
e, ok := a.entities[id]
if !ok {
return nil
}
return e.Value.(*entityEntry).info
} | go | func (a *multiwatcherStore) Get(id multiwatcher.EntityId) multiwatcher.EntityInfo {
e, ok := a.entities[id]
if !ok {
return nil
}
return e.Value.(*entityEntry).info
} | [
"func",
"(",
"a",
"*",
"multiwatcherStore",
")",
"Get",
"(",
"id",
"multiwatcher",
".",
"EntityId",
")",
"multiwatcher",
".",
"EntityInfo",
"{",
"e",
",",
"ok",
":=",
"a",
".",
"entities",
"[",
"id",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
... | // Get returns the stored entity with the given id, or nil if none was found.
// The contents of the returned entity MUST not be changed. | [
"Get",
"returns",
"the",
"stored",
"entity",
"with",
"the",
"given",
"id",
"or",
"nil",
"if",
"none",
"was",
"found",
".",
"The",
"contents",
"of",
"the",
"returned",
"entity",
"MUST",
"not",
"be",
"changed",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/multiwatcher.go#L525-L531 |
155,510 | juju/juju | state/multiwatcher.go | ChangesSince | func (a *multiwatcherStore) ChangesSince(revno int64) []multiwatcher.Delta {
e := a.list.Front()
n := 0
for ; e != nil; e = e.Next() {
entry := e.Value.(*entityEntry)
if entry.revno <= revno {
break
}
n++
}
if e != nil {
// We've found an element that we've already seen.
e = e.Prev()
} else {
// We haven't seen any elements, so we want all of them.
e = a.list.Back()
n++
}
changes := make([]multiwatcher.Delta, 0, n)
for ; e != nil; e = e.Prev() {
entry := e.Value.(*entityEntry)
if entry.removed && entry.creationRevno > revno {
// Don't include entries that have been created
// and removed since the revno.
continue
}
changes = append(changes, multiwatcher.Delta{
Removed: entry.removed,
Entity: entry.info,
})
}
return changes
} | go | func (a *multiwatcherStore) ChangesSince(revno int64) []multiwatcher.Delta {
e := a.list.Front()
n := 0
for ; e != nil; e = e.Next() {
entry := e.Value.(*entityEntry)
if entry.revno <= revno {
break
}
n++
}
if e != nil {
// We've found an element that we've already seen.
e = e.Prev()
} else {
// We haven't seen any elements, so we want all of them.
e = a.list.Back()
n++
}
changes := make([]multiwatcher.Delta, 0, n)
for ; e != nil; e = e.Prev() {
entry := e.Value.(*entityEntry)
if entry.removed && entry.creationRevno > revno {
// Don't include entries that have been created
// and removed since the revno.
continue
}
changes = append(changes, multiwatcher.Delta{
Removed: entry.removed,
Entity: entry.info,
})
}
return changes
} | [
"func",
"(",
"a",
"*",
"multiwatcherStore",
")",
"ChangesSince",
"(",
"revno",
"int64",
")",
"[",
"]",
"multiwatcher",
".",
"Delta",
"{",
"e",
":=",
"a",
".",
"list",
".",
"Front",
"(",
")",
"\n",
"n",
":=",
"0",
"\n",
"for",
";",
"e",
"!=",
"nil... | // ChangesSince returns any changes that have occurred since
// the given revno, oldest first. | [
"ChangesSince",
"returns",
"any",
"changes",
"that",
"have",
"occurred",
"since",
"the",
"given",
"revno",
"oldest",
"first",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/multiwatcher.go#L535-L567 |
155,511 | juju/juju | provider/oracle/provider.go | PrepareConfig | func (e EnvironProvider) PrepareConfig(args environs.PrepareConfigParams) (*config.Config, error) {
if err := e.validateCloudSpec(args.Cloud); err != nil {
return nil, errors.Annotatef(err, "validating cloud spec")
}
// Set the default block-storage source.
attrs := make(map[string]interface{})
if _, ok := args.Config.StorageDefaultBlockSource(); !ok {
attrs[config.StorageDefaultBlockSourceKey] = oracleStorageProviderType
}
if len(attrs) == 0 {
return args.Config, nil
}
return args.Config.Apply(attrs)
} | go | func (e EnvironProvider) PrepareConfig(args environs.PrepareConfigParams) (*config.Config, error) {
if err := e.validateCloudSpec(args.Cloud); err != nil {
return nil, errors.Annotatef(err, "validating cloud spec")
}
// Set the default block-storage source.
attrs := make(map[string]interface{})
if _, ok := args.Config.StorageDefaultBlockSource(); !ok {
attrs[config.StorageDefaultBlockSourceKey] = oracleStorageProviderType
}
if len(attrs) == 0 {
return args.Config, nil
}
return args.Config.Apply(attrs)
} | [
"func",
"(",
"e",
"EnvironProvider",
")",
"PrepareConfig",
"(",
"args",
"environs",
".",
"PrepareConfigParams",
")",
"(",
"*",
"config",
".",
"Config",
",",
"error",
")",
"{",
"if",
"err",
":=",
"e",
".",
"validateCloudSpec",
"(",
"args",
".",
"Cloud",
"... | // PrepareConfig is defined on the environs.EnvironProvider interface. | [
"PrepareConfig",
"is",
"defined",
"on",
"the",
"environs",
".",
"EnvironProvider",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/oracle/provider.go#L42-L55 |
155,512 | juju/juju | provider/oracle/provider.go | validateCloudSpec | func (e EnvironProvider) validateCloudSpec(spec environs.CloudSpec) error {
if err := spec.Validate(); err != nil {
return errors.Trace(err)
}
if spec.Credential == nil {
return errors.NotValidf("missing credentials")
}
// validate the authentication type
if authType := spec.Credential.AuthType(); authType != cloud.UserPassAuthType {
return errors.NotSupportedf("%q auth-type ", authType)
}
if _, ok := spec.Credential.Attributes()["identity-domain"]; !ok {
return errors.NotFoundf("identity-domain in the credentials")
}
return nil
} | go | func (e EnvironProvider) validateCloudSpec(spec environs.CloudSpec) error {
if err := spec.Validate(); err != nil {
return errors.Trace(err)
}
if spec.Credential == nil {
return errors.NotValidf("missing credentials")
}
// validate the authentication type
if authType := spec.Credential.AuthType(); authType != cloud.UserPassAuthType {
return errors.NotSupportedf("%q auth-type ", authType)
}
if _, ok := spec.Credential.Attributes()["identity-domain"]; !ok {
return errors.NotFoundf("identity-domain in the credentials")
}
return nil
} | [
"func",
"(",
"e",
"EnvironProvider",
")",
"validateCloudSpec",
"(",
"spec",
"environs",
".",
"CloudSpec",
")",
"error",
"{",
"if",
"err",
":=",
"spec",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
"(",
"err... | // validateCloudSpec validates the given configuration against the oracle cloud spec | [
"validateCloudSpec",
"validates",
"the",
"given",
"configuration",
"against",
"the",
"oracle",
"cloud",
"spec"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/oracle/provider.go#L58-L76 |
155,513 | juju/juju | provider/oracle/provider.go | Open | func (e *EnvironProvider) Open(params environs.OpenParams) (environs.Environ, error) {
logger.Debugf("opening model %q", params.Config.Name())
if err := e.validateCloudSpec(params.Cloud); err != nil {
return nil, errors.Annotatef(err, "validating cloud spec")
}
cli, err := oci.NewClient(oci.Config{
Username: params.Cloud.Credential.Attributes()["username"],
Password: params.Cloud.Credential.Attributes()["password"],
Endpoint: params.Cloud.Endpoint,
Identify: params.Cloud.Credential.Attributes()["identity-domain"],
})
if err != nil {
return nil, errors.Trace(err)
}
if err = cli.Authenticate(); err != nil {
return nil, errors.Trace(err)
}
return NewOracleEnviron(e, params, cli, clock.WallClock)
} | go | func (e *EnvironProvider) Open(params environs.OpenParams) (environs.Environ, error) {
logger.Debugf("opening model %q", params.Config.Name())
if err := e.validateCloudSpec(params.Cloud); err != nil {
return nil, errors.Annotatef(err, "validating cloud spec")
}
cli, err := oci.NewClient(oci.Config{
Username: params.Cloud.Credential.Attributes()["username"],
Password: params.Cloud.Credential.Attributes()["password"],
Endpoint: params.Cloud.Endpoint,
Identify: params.Cloud.Credential.Attributes()["identity-domain"],
})
if err != nil {
return nil, errors.Trace(err)
}
if err = cli.Authenticate(); err != nil {
return nil, errors.Trace(err)
}
return NewOracleEnviron(e, params, cli, clock.WallClock)
} | [
"func",
"(",
"e",
"*",
"EnvironProvider",
")",
"Open",
"(",
"params",
"environs",
".",
"OpenParams",
")",
"(",
"environs",
".",
"Environ",
",",
"error",
")",
"{",
"logger",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"params",
".",
"Config",
".",
"Name",
"(... | // Open is defined on the environs.EnvironProvider interface. | [
"Open",
"is",
"defined",
"on",
"the",
"environs",
".",
"EnvironProvider",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/oracle/provider.go#L84-L105 |
155,514 | juju/juju | provider/oracle/provider.go | Validate | func (e EnvironProvider) Validate(cfg, old *config.Config) (valid *config.Config, err error) {
if err := config.Validate(cfg, old); err != nil {
return nil, err
}
newAttrs, err := cfg.ValidateUnknownAttrs(
schema.Fields{}, schema.Defaults{},
)
if err != nil {
return nil, err
}
return cfg.Apply(newAttrs)
} | go | func (e EnvironProvider) Validate(cfg, old *config.Config) (valid *config.Config, err error) {
if err := config.Validate(cfg, old); err != nil {
return nil, err
}
newAttrs, err := cfg.ValidateUnknownAttrs(
schema.Fields{}, schema.Defaults{},
)
if err != nil {
return nil, err
}
return cfg.Apply(newAttrs)
} | [
"func",
"(",
"e",
"EnvironProvider",
")",
"Validate",
"(",
"cfg",
",",
"old",
"*",
"config",
".",
"Config",
")",
"(",
"valid",
"*",
"config",
".",
"Config",
",",
"err",
"error",
")",
"{",
"if",
"err",
":=",
"config",
".",
"Validate",
"(",
"cfg",
",... | // Validate is defined on the config.Validator interface. | [
"Validate",
"is",
"defined",
"on",
"the",
"config",
".",
"Validator",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/oracle/provider.go#L108-L120 |
155,515 | juju/juju | provider/oracle/provider.go | FinalizeCredential | func (e EnvironProvider) FinalizeCredential(
cfx environs.FinalizeCredentialContext,
params environs.FinalizeCredentialParams,
) (*cloud.Credential, error) {
return ¶ms.Credential, nil
} | go | func (e EnvironProvider) FinalizeCredential(
cfx environs.FinalizeCredentialContext,
params environs.FinalizeCredentialParams,
) (*cloud.Credential, error) {
return ¶ms.Credential, nil
} | [
"func",
"(",
"e",
"EnvironProvider",
")",
"FinalizeCredential",
"(",
"cfx",
"environs",
".",
"FinalizeCredentialContext",
",",
"params",
"environs",
".",
"FinalizeCredentialParams",
",",
")",
"(",
"*",
"cloud",
".",
"Credential",
",",
"error",
")",
"{",
"return"... | // FinalizeCredential is defined on the environs.ProviderCredentials interface. | [
"FinalizeCredential",
"is",
"defined",
"on",
"the",
"environs",
".",
"ProviderCredentials",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/oracle/provider.go#L150-L156 |
155,516 | juju/juju | cmd/juju/commands/main.go | Main | func Main(args []string) int {
return main{
execCommand: exec.Command,
}.Run(args)
} | go | func Main(args []string) int {
return main{
execCommand: exec.Command,
}.Run(args)
} | [
"func",
"Main",
"(",
"args",
"[",
"]",
"string",
")",
"int",
"{",
"return",
"main",
"{",
"execCommand",
":",
"exec",
".",
"Command",
",",
"}",
".",
"Run",
"(",
"args",
")",
"\n",
"}"
] | // Main registers subcommands for the juju executable, and hands over control
// to the cmd package. This function is not redundant with main, because it
// provides an entry point for testing with arbitrary command line arguments.
// This function returns the exit code, for main to pass to os.Exit. | [
"Main",
"registers",
"subcommands",
"for",
"the",
"juju",
"executable",
"and",
"hands",
"over",
"control",
"to",
"the",
"cmd",
"package",
".",
"This",
"function",
"is",
"not",
"redundant",
"with",
"main",
"because",
"it",
"provides",
"an",
"entry",
"point",
... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/commands/main.go#L86-L90 |
155,517 | juju/juju | cmd/juju/commands/main.go | Run | func (m main) Run(args []string) int {
ctx, err := cmd.DefaultContext()
if err != nil {
cmd.WriteError(os.Stderr, err)
return 2
}
// note that this has to come before we init the juju home directory,
// since it relies on detecting the lack of said directory.
newInstall := m.maybeWarnJuju1x()
if err = juju.InitJujuXDGDataHome(); err != nil {
cmd.WriteError(ctx.Stderr, err)
return 2
}
if err := installProxy(); err != nil {
cmd.WriteError(ctx.Stderr, err)
return 2
}
if newInstall {
fmt.Fprintf(ctx.Stderr, "Since Juju %v is being run for the first time, downloading latest cloud information.\n", jujuversion.Current.Major)
updateCmd := cloud.NewUpdatePublicCloudsCommand()
if err := updateCmd.Run(ctx); err != nil {
cmd.WriteError(ctx.Stderr, err)
}
}
for i := range x {
x[i] ^= 255
}
if len(args) == 2 {
if args[1] == string(x[0:2]) {
os.Stdout.Write(x[9:])
return 0
}
if args[1] == string(x[2:9]) {
os.Stdout.Write(model.ExtractCert())
return 0
}
}
jcmd := NewJujuCommand(ctx)
return cmd.Main(jcmd, ctx, args[1:])
} | go | func (m main) Run(args []string) int {
ctx, err := cmd.DefaultContext()
if err != nil {
cmd.WriteError(os.Stderr, err)
return 2
}
// note that this has to come before we init the juju home directory,
// since it relies on detecting the lack of said directory.
newInstall := m.maybeWarnJuju1x()
if err = juju.InitJujuXDGDataHome(); err != nil {
cmd.WriteError(ctx.Stderr, err)
return 2
}
if err := installProxy(); err != nil {
cmd.WriteError(ctx.Stderr, err)
return 2
}
if newInstall {
fmt.Fprintf(ctx.Stderr, "Since Juju %v is being run for the first time, downloading latest cloud information.\n", jujuversion.Current.Major)
updateCmd := cloud.NewUpdatePublicCloudsCommand()
if err := updateCmd.Run(ctx); err != nil {
cmd.WriteError(ctx.Stderr, err)
}
}
for i := range x {
x[i] ^= 255
}
if len(args) == 2 {
if args[1] == string(x[0:2]) {
os.Stdout.Write(x[9:])
return 0
}
if args[1] == string(x[2:9]) {
os.Stdout.Write(model.ExtractCert())
return 0
}
}
jcmd := NewJujuCommand(ctx)
return cmd.Main(jcmd, ctx, args[1:])
} | [
"func",
"(",
"m",
"main",
")",
"Run",
"(",
"args",
"[",
"]",
"string",
")",
"int",
"{",
"ctx",
",",
"err",
":=",
"cmd",
".",
"DefaultContext",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"cmd",
".",
"WriteError",
"(",
"os",
".",
"Stderr",
",... | // Run is the main entry point for the juju client. | [
"Run",
"is",
"the",
"main",
"entry",
"point",
"for",
"the",
"juju",
"client",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/commands/main.go#L99-L144 |
155,518 | juju/juju | apiserver/authentication/user.go | Authenticate | func (u *UserAuthenticator) Authenticate(
entityFinder EntityFinder, tag names.Tag, req params.LoginRequest,
) (state.Entity, error) {
userTag, ok := tag.(names.UserTag)
if !ok {
return nil, errors.Errorf("invalid request")
}
if req.Credentials == "" && userTag.IsLocal() {
return u.authenticateMacaroons(entityFinder, userTag, req)
}
return u.AgentAuthenticator.Authenticate(entityFinder, tag, req)
} | go | func (u *UserAuthenticator) Authenticate(
entityFinder EntityFinder, tag names.Tag, req params.LoginRequest,
) (state.Entity, error) {
userTag, ok := tag.(names.UserTag)
if !ok {
return nil, errors.Errorf("invalid request")
}
if req.Credentials == "" && userTag.IsLocal() {
return u.authenticateMacaroons(entityFinder, userTag, req)
}
return u.AgentAuthenticator.Authenticate(entityFinder, tag, req)
} | [
"func",
"(",
"u",
"*",
"UserAuthenticator",
")",
"Authenticate",
"(",
"entityFinder",
"EntityFinder",
",",
"tag",
"names",
".",
"Tag",
",",
"req",
"params",
".",
"LoginRequest",
",",
")",
"(",
"state",
".",
"Entity",
",",
"error",
")",
"{",
"userTag",
",... | // Authenticate authenticates the entity with the specified tag, and returns an
// error on authentication failure.
//
// If and only if no password is supplied, then Authenticate will check for any
// valid macaroons. Otherwise, password authentication will be performed. | [
"Authenticate",
"authenticates",
"the",
"entity",
"with",
"the",
"specified",
"tag",
"and",
"returns",
"an",
"error",
"on",
"authentication",
"failure",
".",
"If",
"and",
"only",
"if",
"no",
"password",
"is",
"supplied",
"then",
"Authenticate",
"will",
"check",
... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/apiserver/authentication/user.go#L67-L78 |
155,519 | juju/juju | provider/azure/internal/useragent/useragent.go | UpdateClient | func UpdateClient(client *autorest.Client) {
if client.UserAgent == "" {
client.UserAgent = JujuPrefix()
} else {
client.UserAgent = JujuPrefix() + " " + client.UserAgent
}
} | go | func UpdateClient(client *autorest.Client) {
if client.UserAgent == "" {
client.UserAgent = JujuPrefix()
} else {
client.UserAgent = JujuPrefix() + " " + client.UserAgent
}
} | [
"func",
"UpdateClient",
"(",
"client",
"*",
"autorest",
".",
"Client",
")",
"{",
"if",
"client",
".",
"UserAgent",
"==",
"\"",
"\"",
"{",
"client",
".",
"UserAgent",
"=",
"JujuPrefix",
"(",
")",
"\n",
"}",
"else",
"{",
"client",
".",
"UserAgent",
"=",
... | // UpdateClient updates the UserAgent field of the given autorest.Client. | [
"UpdateClient",
"updates",
"the",
"UserAgent",
"field",
"of",
"the",
"given",
"autorest",
".",
"Client",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/azure/internal/useragent/useragent.go#L18-L24 |
155,520 | juju/juju | cmd/jujud/agent/caasoperator.go | NewCaasOperatorAgent | func NewCaasOperatorAgent(ctx *cmd.Context, bufferedLogger *logsender.BufferedLogWriter) (*CaasOperatorAgent, error) {
prometheusRegistry, err := newPrometheusRegistry()
if err != nil {
return nil, errors.Trace(err)
}
return &CaasOperatorAgent{
AgentConf: NewAgentConf(""),
configChangedVal: voyeur.NewValue(true),
ctx: ctx,
dead: make(chan struct{}),
bufferedLogger: bufferedLogger,
prometheusRegistry: prometheusRegistry,
preUpgradeSteps: upgrades.PreUpgradeSteps,
}, nil
} | go | func NewCaasOperatorAgent(ctx *cmd.Context, bufferedLogger *logsender.BufferedLogWriter) (*CaasOperatorAgent, error) {
prometheusRegistry, err := newPrometheusRegistry()
if err != nil {
return nil, errors.Trace(err)
}
return &CaasOperatorAgent{
AgentConf: NewAgentConf(""),
configChangedVal: voyeur.NewValue(true),
ctx: ctx,
dead: make(chan struct{}),
bufferedLogger: bufferedLogger,
prometheusRegistry: prometheusRegistry,
preUpgradeSteps: upgrades.PreUpgradeSteps,
}, nil
} | [
"func",
"NewCaasOperatorAgent",
"(",
"ctx",
"*",
"cmd",
".",
"Context",
",",
"bufferedLogger",
"*",
"logsender",
".",
"BufferedLogWriter",
")",
"(",
"*",
"CaasOperatorAgent",
",",
"error",
")",
"{",
"prometheusRegistry",
",",
"err",
":=",
"newPrometheusRegistry",
... | // NewCaasOperatorAgent creates a new CAASOperatorAgent instance properly initialized. | [
"NewCaasOperatorAgent",
"creates",
"a",
"new",
"CAASOperatorAgent",
"instance",
"properly",
"initialized",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/jujud/agent/caasoperator.go#L69-L83 |
155,521 | juju/juju | cmd/jujud/agent/caasoperator.go | maybeCopyAgentConfig | func (op *CaasOperatorAgent) maybeCopyAgentConfig() error {
err := op.ReadConfig(op.Tag().String())
if err == nil {
return nil
}
if !os.IsNotExist(errors.Cause(err)) {
logger.Errorf("reading initial agent config file: %v", err)
return errors.Trace(err)
}
templateFile := filepath.Join(agent.Dir(op.DataDir(), op.Tag()), caasprovider.TemplateFileNameAgentConf)
if err := copyFile(agent.ConfigPath(op.DataDir(), op.Tag()), templateFile); err != nil {
logger.Errorf("copying agent config file template: %v", err)
return errors.Trace(err)
}
return op.ReadConfig(op.Tag().String())
} | go | func (op *CaasOperatorAgent) maybeCopyAgentConfig() error {
err := op.ReadConfig(op.Tag().String())
if err == nil {
return nil
}
if !os.IsNotExist(errors.Cause(err)) {
logger.Errorf("reading initial agent config file: %v", err)
return errors.Trace(err)
}
templateFile := filepath.Join(agent.Dir(op.DataDir(), op.Tag()), caasprovider.TemplateFileNameAgentConf)
if err := copyFile(agent.ConfigPath(op.DataDir(), op.Tag()), templateFile); err != nil {
logger.Errorf("copying agent config file template: %v", err)
return errors.Trace(err)
}
return op.ReadConfig(op.Tag().String())
} | [
"func",
"(",
"op",
"*",
"CaasOperatorAgent",
")",
"maybeCopyAgentConfig",
"(",
")",
"error",
"{",
"err",
":=",
"op",
".",
"ReadConfig",
"(",
"op",
".",
"Tag",
"(",
")",
".",
"String",
"(",
")",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"n... | // maybeCopyAgentConfig copies the read-only agent config template
// to the writeable agent config file if the file doesn't yet exist. | [
"maybeCopyAgentConfig",
"copies",
"the",
"read",
"-",
"only",
"agent",
"config",
"template",
"to",
"the",
"writeable",
"agent",
"config",
"file",
"if",
"the",
"file",
"doesn",
"t",
"yet",
"exist",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/jujud/agent/caasoperator.go#L138-L153 |
155,522 | juju/juju | cmd/jujud/agent/caasoperator.go | Workers | func (op *CaasOperatorAgent) Workers() (worker.Worker, error) {
updateAgentConfLogging := func(loggingConfig string) error {
return op.AgentConf.ChangeConfig(func(setter agent.ConfigSetter) error {
setter.SetLoggingConfig(loggingConfig)
return nil
})
}
agentConfig := op.AgentConf.CurrentConfig()
manifolds := CaasOperatorManifolds(caasoperator.ManifoldsConfig{
Agent: agent.APIHostPortsSetter{op},
AgentConfigChanged: op.configChangedVal,
Clock: clock.WallClock,
LogSource: op.bufferedLogger.Logs(),
UpdateLoggerConfig: updateAgentConfLogging,
PrometheusRegisterer: op.prometheusRegistry,
LeadershipGuarantee: 15 * time.Second,
PreUpgradeSteps: op.preUpgradeSteps,
UpgradeStepsLock: op.upgradeComplete,
ValidateMigration: op.validateMigration,
MachineLock: op.machineLock,
PreviousAgentVersion: agentConfig.UpgradedToVersion(),
})
engine, err := dependency.NewEngine(dependencyEngineConfig())
if err != nil {
return nil, err
}
if err := dependency.Install(engine, manifolds); err != nil {
if err := worker.Stop(engine); err != nil {
logger.Errorf("while stopping engine with bad manifolds: %v", err)
}
return nil, err
}
if err := startIntrospection(introspectionConfig{
Agent: op,
Engine: engine,
MachineLock: op.machineLock,
NewSocketName: DefaultIntrospectionSocketName,
PrometheusGatherer: op.prometheusRegistry,
WorkerFunc: introspection.NewWorker,
}); err != nil {
// If the introspection worker failed to start, we just log error
// but continue. It is very unlikely to happen in the real world
// as the only issue is connecting to the abstract domain socket
// and the agent is controlled by by the OS to only have one.
logger.Errorf("failed to start introspection worker: %v", err)
}
return engine, nil
} | go | func (op *CaasOperatorAgent) Workers() (worker.Worker, error) {
updateAgentConfLogging := func(loggingConfig string) error {
return op.AgentConf.ChangeConfig(func(setter agent.ConfigSetter) error {
setter.SetLoggingConfig(loggingConfig)
return nil
})
}
agentConfig := op.AgentConf.CurrentConfig()
manifolds := CaasOperatorManifolds(caasoperator.ManifoldsConfig{
Agent: agent.APIHostPortsSetter{op},
AgentConfigChanged: op.configChangedVal,
Clock: clock.WallClock,
LogSource: op.bufferedLogger.Logs(),
UpdateLoggerConfig: updateAgentConfLogging,
PrometheusRegisterer: op.prometheusRegistry,
LeadershipGuarantee: 15 * time.Second,
PreUpgradeSteps: op.preUpgradeSteps,
UpgradeStepsLock: op.upgradeComplete,
ValidateMigration: op.validateMigration,
MachineLock: op.machineLock,
PreviousAgentVersion: agentConfig.UpgradedToVersion(),
})
engine, err := dependency.NewEngine(dependencyEngineConfig())
if err != nil {
return nil, err
}
if err := dependency.Install(engine, manifolds); err != nil {
if err := worker.Stop(engine); err != nil {
logger.Errorf("while stopping engine with bad manifolds: %v", err)
}
return nil, err
}
if err := startIntrospection(introspectionConfig{
Agent: op,
Engine: engine,
MachineLock: op.machineLock,
NewSocketName: DefaultIntrospectionSocketName,
PrometheusGatherer: op.prometheusRegistry,
WorkerFunc: introspection.NewWorker,
}); err != nil {
// If the introspection worker failed to start, we just log error
// but continue. It is very unlikely to happen in the real world
// as the only issue is connecting to the abstract domain socket
// and the agent is controlled by by the OS to only have one.
logger.Errorf("failed to start introspection worker: %v", err)
}
return engine, nil
} | [
"func",
"(",
"op",
"*",
"CaasOperatorAgent",
")",
"Workers",
"(",
")",
"(",
"worker",
".",
"Worker",
",",
"error",
")",
"{",
"updateAgentConfLogging",
":=",
"func",
"(",
"loggingConfig",
"string",
")",
"error",
"{",
"return",
"op",
".",
"AgentConf",
".",
... | // Workers returns a dependency.Engine running the operator's responsibilities. | [
"Workers",
"returns",
"a",
"dependency",
".",
"Engine",
"running",
"the",
"operator",
"s",
"responsibilities",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/jujud/agent/caasoperator.go#L203-L252 |
155,523 | juju/juju | cmd/jujud/agent/caasoperator.go | ChangeConfig | func (op *CaasOperatorAgent) ChangeConfig(mutate agent.ConfigMutator) error {
err := op.AgentConf.ChangeConfig(mutate)
op.configChangedVal.Set(true)
return errors.Trace(err)
} | go | func (op *CaasOperatorAgent) ChangeConfig(mutate agent.ConfigMutator) error {
err := op.AgentConf.ChangeConfig(mutate)
op.configChangedVal.Set(true)
return errors.Trace(err)
} | [
"func",
"(",
"op",
"*",
"CaasOperatorAgent",
")",
"ChangeConfig",
"(",
"mutate",
"agent",
".",
"ConfigMutator",
")",
"error",
"{",
"err",
":=",
"op",
".",
"AgentConf",
".",
"ChangeConfig",
"(",
"mutate",
")",
"\n",
"op",
".",
"configChangedVal",
".",
"Set"... | // ChangeConfig implements Agent. | [
"ChangeConfig",
"implements",
"Agent",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/jujud/agent/caasoperator.go#L260-L264 |
155,524 | juju/juju | cmd/jujud/agent/checkconnection.go | ConnectAsAgent | func ConnectAsAgent(a agent.Agent) (io.Closer, error) {
return apicaller.ScaryConnect(a, api.Open)
} | go | func ConnectAsAgent(a agent.Agent) (io.Closer, error) {
return apicaller.ScaryConnect(a, api.Open)
} | [
"func",
"ConnectAsAgent",
"(",
"a",
"agent",
".",
"Agent",
")",
"(",
"io",
".",
"Closer",
",",
"error",
")",
"{",
"return",
"apicaller",
".",
"ScaryConnect",
"(",
"a",
",",
"api",
".",
"Open",
")",
"\n",
"}"
] | // ConnectAsAgent really connects to the API specified in the agent
// config. It's extracted so tests can pass something else in. | [
"ConnectAsAgent",
"really",
"connects",
"to",
"the",
"API",
"specified",
"in",
"the",
"agent",
"config",
".",
"It",
"s",
"extracted",
"so",
"tests",
"can",
"pass",
"something",
"else",
"in",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/jujud/agent/checkconnection.go#L25-L27 |
155,525 | juju/juju | cmd/jujud/agent/checkconnection.go | NewCheckConnectionCommand | func NewCheckConnectionCommand(config AgentConf, connect ConnectFunc) cmd.Command {
return &checkConnectionCommand{
config: config,
connect: connect,
}
} | go | func NewCheckConnectionCommand(config AgentConf, connect ConnectFunc) cmd.Command {
return &checkConnectionCommand{
config: config,
connect: connect,
}
} | [
"func",
"NewCheckConnectionCommand",
"(",
"config",
"AgentConf",
",",
"connect",
"ConnectFunc",
")",
"cmd",
".",
"Command",
"{",
"return",
"&",
"checkConnectionCommand",
"{",
"config",
":",
"config",
",",
"connect",
":",
"connect",
",",
"}",
"\n",
"}"
] | // NewCheckConnectionCommand returns a command that will test
// connecting to the API with details from the agent's config. | [
"NewCheckConnectionCommand",
"returns",
"a",
"command",
"that",
"will",
"test",
"connecting",
"to",
"the",
"API",
"with",
"details",
"from",
"the",
"agent",
"s",
"config",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/jujud/agent/checkconnection.go#L38-L43 |
155,526 | juju/juju | worker/meterstatus/isolated.go | NewIsolatedStatusWorker | func NewIsolatedStatusWorker(cfg IsolatedConfig) (worker.Worker, error) {
if err := cfg.Validate(); err != nil {
return nil, errors.Trace(err)
}
w := &isolatedStatusWorker{
config: cfg,
}
w.tomb.Go(w.loop)
return w, nil
} | go | func NewIsolatedStatusWorker(cfg IsolatedConfig) (worker.Worker, error) {
if err := cfg.Validate(); err != nil {
return nil, errors.Trace(err)
}
w := &isolatedStatusWorker{
config: cfg,
}
w.tomb.Go(w.loop)
return w, nil
} | [
"func",
"NewIsolatedStatusWorker",
"(",
"cfg",
"IsolatedConfig",
")",
"(",
"worker",
".",
"Worker",
",",
"error",
")",
"{",
"if",
"err",
":=",
"cfg",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Trace",... | // NewIsolatedStatusWorker creates a new status worker that runs without an API connection. | [
"NewIsolatedStatusWorker",
"creates",
"a",
"new",
"status",
"worker",
"that",
"runs",
"without",
"an",
"API",
"connection",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/meterstatus/isolated.go#L84-L93 |
155,527 | juju/juju | state/model.go | ParseModelType | func ParseModelType(raw string) (ModelType, error) {
for _, typ := range []ModelType{ModelTypeIAAS, ModelTypeCAAS} {
if raw == string(typ) {
return typ, nil
}
}
return "", errors.NotValidf("model type %v", raw)
} | go | func ParseModelType(raw string) (ModelType, error) {
for _, typ := range []ModelType{ModelTypeIAAS, ModelTypeCAAS} {
if raw == string(typ) {
return typ, nil
}
}
return "", errors.NotValidf("model type %v", raw)
} | [
"func",
"ParseModelType",
"(",
"raw",
"string",
")",
"(",
"ModelType",
",",
"error",
")",
"{",
"for",
"_",
",",
"typ",
":=",
"range",
"[",
"]",
"ModelType",
"{",
"ModelTypeIAAS",
",",
"ModelTypeCAAS",
"}",
"{",
"if",
"raw",
"==",
"string",
"(",
"typ",
... | // ParseModelType turns a valid model type string into a ModelType
// constant. | [
"ParseModelType",
"turns",
"a",
"valid",
"model",
"type",
"string",
"into",
"a",
"ModelType",
"constant",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L48-L55 |
155,528 | juju/juju | state/model.go | String | func (l slaLevel) String() string {
if l == slaNone {
l = SLAUnsupported
}
return string(l)
} | go | func (l slaLevel) String() string {
if l == slaNone {
l = SLAUnsupported
}
return string(l)
} | [
"func",
"(",
"l",
"slaLevel",
")",
"String",
"(",
")",
"string",
"{",
"if",
"l",
"==",
"slaNone",
"{",
"l",
"=",
"SLAUnsupported",
"\n",
"}",
"\n",
"return",
"string",
"(",
"l",
")",
"\n",
"}"
] | // String implements fmt.Stringer returning the string representation of an
// SLALevel. | [
"String",
"implements",
"fmt",
".",
"Stringer",
"returning",
"the",
"string",
"representation",
"of",
"an",
"SLALevel",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L131-L136 |
155,529 | juju/juju | state/model.go | newSLALevel | func newSLALevel(level string) (slaLevel, error) {
l := slaLevel(level)
if l == slaNone {
l = SLAUnsupported
}
switch l {
case SLAUnsupported, SLAEssential, SLAStandard, SLAAdvanced:
return l, nil
}
return l, errors.NotValidf("SLA level %q", level)
} | go | func newSLALevel(level string) (slaLevel, error) {
l := slaLevel(level)
if l == slaNone {
l = SLAUnsupported
}
switch l {
case SLAUnsupported, SLAEssential, SLAStandard, SLAAdvanced:
return l, nil
}
return l, errors.NotValidf("SLA level %q", level)
} | [
"func",
"newSLALevel",
"(",
"level",
"string",
")",
"(",
"slaLevel",
",",
"error",
")",
"{",
"l",
":=",
"slaLevel",
"(",
"level",
")",
"\n",
"if",
"l",
"==",
"slaNone",
"{",
"l",
"=",
"SLAUnsupported",
"\n",
"}",
"\n",
"switch",
"l",
"{",
"case",
"... | // newSLALevel returns a new SLA level from a string representation. | [
"newSLALevel",
"returns",
"a",
"new",
"SLA",
"level",
"from",
"a",
"string",
"representation",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L139-L149 |
155,530 | juju/juju | state/model.go | filteredModelUUIDs | func (st *State) filteredModelUUIDs(filter bson.D) ([]string, error) {
models, closer := st.db().GetCollection(modelsC)
defer closer()
var docs []bson.M
err := models.Find(filter).Sort("name", "owner").Select(bson.M{"_id": 1}).All(&docs)
if err != nil {
return nil, err
}
out := make([]string, len(docs))
for i, doc := range docs {
out[i] = doc["_id"].(string)
}
return out, nil
} | go | func (st *State) filteredModelUUIDs(filter bson.D) ([]string, error) {
models, closer := st.db().GetCollection(modelsC)
defer closer()
var docs []bson.M
err := models.Find(filter).Sort("name", "owner").Select(bson.M{"_id": 1}).All(&docs)
if err != nil {
return nil, err
}
out := make([]string, len(docs))
for i, doc := range docs {
out[i] = doc["_id"].(string)
}
return out, nil
} | [
"func",
"(",
"st",
"*",
"State",
")",
"filteredModelUUIDs",
"(",
"filter",
"bson",
".",
"D",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"models",
",",
"closer",
":=",
"st",
".",
"db",
"(",
")",
".",
"GetCollection",
"(",
"modelsC",
")",
... | // filteredModelUUIDs returns all model uuids that match the filter. | [
"filteredModelUUIDs",
"returns",
"all",
"model",
"uuids",
"that",
"match",
"the",
"filter",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L213-L227 |
155,531 | juju/juju | state/model.go | ModelExists | func (st *State) ModelExists(uuid string) (bool, error) {
models, closer := st.db().GetCollection(modelsC)
defer closer()
count, err := models.FindId(uuid).Count()
if err != nil {
return false, errors.Annotate(err, "querying model")
}
return count > 0, nil
} | go | func (st *State) ModelExists(uuid string) (bool, error) {
models, closer := st.db().GetCollection(modelsC)
defer closer()
count, err := models.FindId(uuid).Count()
if err != nil {
return false, errors.Annotate(err, "querying model")
}
return count > 0, nil
} | [
"func",
"(",
"st",
"*",
"State",
")",
"ModelExists",
"(",
"uuid",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"models",
",",
"closer",
":=",
"st",
".",
"db",
"(",
")",
".",
"GetCollection",
"(",
"modelsC",
")",
"\n",
"defer",
"closer",
"(",... | // ModelExists returns true if a model with the supplied UUID exists. | [
"ModelExists",
"returns",
"true",
"if",
"a",
"model",
"with",
"the",
"supplied",
"UUID",
"exists",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L230-L239 |
155,532 | juju/juju | state/model.go | Validate | func (m ModelArgs) Validate() error {
if m.Type == modelTypeNone {
return errors.NotValidf("empty Type")
}
if m.Config == nil {
return errors.NotValidf("nil Config")
}
if !names.IsValidCloud(m.CloudName) {
return errors.NotValidf("Cloud Name %q", m.CloudName)
}
if m.Owner == (names.UserTag{}) {
return errors.NotValidf("empty Owner")
}
if m.StorageProviderRegistry == nil {
return errors.NotValidf("nil StorageProviderRegistry")
}
switch m.MigrationMode {
case MigrationModeNone, MigrationModeImporting:
default:
return errors.NotValidf("initial migration mode %q", m.MigrationMode)
}
return nil
} | go | func (m ModelArgs) Validate() error {
if m.Type == modelTypeNone {
return errors.NotValidf("empty Type")
}
if m.Config == nil {
return errors.NotValidf("nil Config")
}
if !names.IsValidCloud(m.CloudName) {
return errors.NotValidf("Cloud Name %q", m.CloudName)
}
if m.Owner == (names.UserTag{}) {
return errors.NotValidf("empty Owner")
}
if m.StorageProviderRegistry == nil {
return errors.NotValidf("nil StorageProviderRegistry")
}
switch m.MigrationMode {
case MigrationModeNone, MigrationModeImporting:
default:
return errors.NotValidf("initial migration mode %q", m.MigrationMode)
}
return nil
} | [
"func",
"(",
"m",
"ModelArgs",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"m",
".",
"Type",
"==",
"modelTypeNone",
"{",
"return",
"errors",
".",
"NotValidf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"m",
".",
"Config",
"==",
"nil",
"{",
"... | // Validate validates the ModelArgs. | [
"Validate",
"validates",
"the",
"ModelArgs",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L279-L301 |
155,533 | juju/juju | state/model.go | validateCloudRegion | func validateCloudRegion(cloud jujucloud.Cloud, regionName string) (txn.Op, error) {
// Ensure that the cloud region is valid, or if one is not specified,
// that the cloud does not support regions.
assertCloudRegionOp := txn.Op{
C: cloudsC,
Id: cloud.Name,
}
if regionName != "" {
region, err := jujucloud.RegionByName(cloud.Regions, regionName)
if err != nil {
return txn.Op{}, errors.Trace(err)
}
assertCloudRegionOp.Assert = bson.D{
{"regions." + utils.EscapeKey(region.Name), bson.D{{"$exists", true}}},
}
} else {
if len(cloud.Regions) > 0 {
return txn.Op{}, errors.NotValidf("missing CloudRegion")
}
assertCloudRegionOp.Assert = bson.D{
{"regions", bson.D{{"$exists", false}}},
}
}
return assertCloudRegionOp, nil
} | go | func validateCloudRegion(cloud jujucloud.Cloud, regionName string) (txn.Op, error) {
// Ensure that the cloud region is valid, or if one is not specified,
// that the cloud does not support regions.
assertCloudRegionOp := txn.Op{
C: cloudsC,
Id: cloud.Name,
}
if regionName != "" {
region, err := jujucloud.RegionByName(cloud.Regions, regionName)
if err != nil {
return txn.Op{}, errors.Trace(err)
}
assertCloudRegionOp.Assert = bson.D{
{"regions." + utils.EscapeKey(region.Name), bson.D{{"$exists", true}}},
}
} else {
if len(cloud.Regions) > 0 {
return txn.Op{}, errors.NotValidf("missing CloudRegion")
}
assertCloudRegionOp.Assert = bson.D{
{"regions", bson.D{{"$exists", false}}},
}
}
return assertCloudRegionOp, nil
} | [
"func",
"validateCloudRegion",
"(",
"cloud",
"jujucloud",
".",
"Cloud",
",",
"regionName",
"string",
")",
"(",
"txn",
".",
"Op",
",",
"error",
")",
"{",
"// Ensure that the cloud region is valid, or if one is not specified,",
"// that the cloud does not support regions.",
"... | // validateCloudRegion validates the given region name against the
// provided Cloud definition, and returns a txn.Op to include in a
// transaction to assert the same. | [
"validateCloudRegion",
"validates",
"the",
"given",
"region",
"name",
"against",
"the",
"provided",
"Cloud",
"definition",
"and",
"returns",
"a",
"txn",
".",
"Op",
"to",
"include",
"in",
"a",
"transaction",
"to",
"assert",
"the",
"same",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L470-L494 |
155,534 | juju/juju | state/model.go | validateCloudCredential | func validateCloudCredential(
cloud jujucloud.Cloud,
cloudCredentials map[string]Credential,
cloudCredential names.CloudCredentialTag,
) (txn.Op, error) {
if cloudCredential != (names.CloudCredentialTag{}) {
if cloudCredential.Cloud().Id() != cloud.Name {
return txn.Op{}, errors.NotValidf("credential %q", cloudCredential.Id())
}
var found bool
for tag := range cloudCredentials {
if tag == cloudCredential.Id() {
found = true
break
}
}
if !found {
return txn.Op{}, errors.NotFoundf("credential %q", cloudCredential.Id())
}
// NOTE(axw) if we add ACLs for credentials,
// we'll need to check access here. The map
// we check above contains only the credentials
// that the model owner has access to.
return txn.Op{
C: cloudCredentialsC,
Id: cloudCredentialDocID(cloudCredential),
Assert: txn.DocExists,
}, nil
}
var hasEmptyAuth bool
for _, authType := range cloud.AuthTypes {
if authType != jujucloud.EmptyAuthType {
continue
}
hasEmptyAuth = true
break
}
if !hasEmptyAuth {
return txn.Op{}, errors.NotValidf("missing CloudCredential")
}
return txn.Op{
C: cloudsC,
Id: cloud.Name,
Assert: bson.D{{"auth-types", string(jujucloud.EmptyAuthType)}},
}, nil
} | go | func validateCloudCredential(
cloud jujucloud.Cloud,
cloudCredentials map[string]Credential,
cloudCredential names.CloudCredentialTag,
) (txn.Op, error) {
if cloudCredential != (names.CloudCredentialTag{}) {
if cloudCredential.Cloud().Id() != cloud.Name {
return txn.Op{}, errors.NotValidf("credential %q", cloudCredential.Id())
}
var found bool
for tag := range cloudCredentials {
if tag == cloudCredential.Id() {
found = true
break
}
}
if !found {
return txn.Op{}, errors.NotFoundf("credential %q", cloudCredential.Id())
}
// NOTE(axw) if we add ACLs for credentials,
// we'll need to check access here. The map
// we check above contains only the credentials
// that the model owner has access to.
return txn.Op{
C: cloudCredentialsC,
Id: cloudCredentialDocID(cloudCredential),
Assert: txn.DocExists,
}, nil
}
var hasEmptyAuth bool
for _, authType := range cloud.AuthTypes {
if authType != jujucloud.EmptyAuthType {
continue
}
hasEmptyAuth = true
break
}
if !hasEmptyAuth {
return txn.Op{}, errors.NotValidf("missing CloudCredential")
}
return txn.Op{
C: cloudsC,
Id: cloud.Name,
Assert: bson.D{{"auth-types", string(jujucloud.EmptyAuthType)}},
}, nil
} | [
"func",
"validateCloudCredential",
"(",
"cloud",
"jujucloud",
".",
"Cloud",
",",
"cloudCredentials",
"map",
"[",
"string",
"]",
"Credential",
",",
"cloudCredential",
"names",
".",
"CloudCredentialTag",
",",
")",
"(",
"txn",
".",
"Op",
",",
"error",
")",
"{",
... | // validateCloudCredential validates the given cloud credential
// name against the provided cloud definition and credentials,
// and returns a txn.Op to include in a transaction to assert the
// same. A user is supplied, for which access to the credential
// will be asserted. | [
"validateCloudCredential",
"validates",
"the",
"given",
"cloud",
"credential",
"name",
"against",
"the",
"provided",
"cloud",
"definition",
"and",
"credentials",
"and",
"returns",
"a",
"txn",
".",
"Op",
"to",
"include",
"in",
"a",
"transaction",
"to",
"assert",
... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L501-L546 |
155,535 | juju/juju | state/model.go | ModelTag | func (m *Model) ModelTag() names.ModelTag {
return names.NewModelTag(m.doc.UUID)
} | go | func (m *Model) ModelTag() names.ModelTag {
return names.NewModelTag(m.doc.UUID)
} | [
"func",
"(",
"m",
"*",
"Model",
")",
"ModelTag",
"(",
")",
"names",
".",
"ModelTag",
"{",
"return",
"names",
".",
"NewModelTag",
"(",
"m",
".",
"doc",
".",
"UUID",
")",
"\n",
"}"
] | // ModelTag is the concrete model tag for this model. | [
"ModelTag",
"is",
"the",
"concrete",
"model",
"tag",
"for",
"this",
"model",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L556-L558 |
155,536 | juju/juju | state/model.go | ControllerTag | func (m *Model) ControllerTag() names.ControllerTag {
return names.NewControllerTag(m.doc.ControllerUUID)
} | go | func (m *Model) ControllerTag() names.ControllerTag {
return names.NewControllerTag(m.doc.ControllerUUID)
} | [
"func",
"(",
"m",
"*",
"Model",
")",
"ControllerTag",
"(",
")",
"names",
".",
"ControllerTag",
"{",
"return",
"names",
".",
"NewControllerTag",
"(",
"m",
".",
"doc",
".",
"ControllerUUID",
")",
"\n",
"}"
] | // ControllerTag is the tag for the controller that the model is
// running within. | [
"ControllerTag",
"is",
"the",
"tag",
"for",
"the",
"controller",
"that",
"the",
"model",
"is",
"running",
"within",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L562-L564 |
155,537 | juju/juju | state/model.go | CloudCredential | func (m *Model) CloudCredential() (names.CloudCredentialTag, bool) {
if names.IsValidCloudCredential(m.doc.CloudCredential) {
return names.NewCloudCredentialTag(m.doc.CloudCredential), true
}
return names.CloudCredentialTag{}, false
} | go | func (m *Model) CloudCredential() (names.CloudCredentialTag, bool) {
if names.IsValidCloudCredential(m.doc.CloudCredential) {
return names.NewCloudCredentialTag(m.doc.CloudCredential), true
}
return names.CloudCredentialTag{}, false
} | [
"func",
"(",
"m",
"*",
"Model",
")",
"CloudCredential",
"(",
")",
"(",
"names",
".",
"CloudCredentialTag",
",",
"bool",
")",
"{",
"if",
"names",
".",
"IsValidCloudCredential",
"(",
"m",
".",
"doc",
".",
"CloudCredential",
")",
"{",
"return",
"names",
"."... | // CloudCredential returns the tag of the cloud credential used for managing the
// model's cloud resources, and a boolean indicating whether a credential is set. | [
"CloudCredential",
"returns",
"the",
"tag",
"of",
"the",
"cloud",
"credential",
"used",
"for",
"managing",
"the",
"model",
"s",
"cloud",
"resources",
"and",
"a",
"boolean",
"indicating",
"whether",
"a",
"credential",
"is",
"set",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L599-L604 |
155,538 | juju/juju | state/model.go | SetMigrationMode | func (m *Model) SetMigrationMode(mode MigrationMode) error {
ops := []txn.Op{{
C: modelsC,
Id: m.doc.UUID,
Assert: txn.DocExists,
Update: bson.D{{"$set", bson.D{{"migration-mode", mode}}}},
}}
if err := m.st.db().RunTransaction(ops); err != nil {
return errors.Trace(err)
}
return m.Refresh()
} | go | func (m *Model) SetMigrationMode(mode MigrationMode) error {
ops := []txn.Op{{
C: modelsC,
Id: m.doc.UUID,
Assert: txn.DocExists,
Update: bson.D{{"$set", bson.D{{"migration-mode", mode}}}},
}}
if err := m.st.db().RunTransaction(ops); err != nil {
return errors.Trace(err)
}
return m.Refresh()
} | [
"func",
"(",
"m",
"*",
"Model",
")",
"SetMigrationMode",
"(",
"mode",
"MigrationMode",
")",
"error",
"{",
"ops",
":=",
"[",
"]",
"txn",
".",
"Op",
"{",
"{",
"C",
":",
"modelsC",
",",
"Id",
":",
"m",
".",
"doc",
".",
"UUID",
",",
"Assert",
":",
... | // SetMigrationMode updates the migration mode of the model. | [
"SetMigrationMode",
"updates",
"the",
"migration",
"mode",
"of",
"the",
"model",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L612-L623 |
155,539 | juju/juju | state/model.go | Owner | func (m *Model) Owner() names.UserTag {
return names.NewUserTag(m.doc.Owner)
} | go | func (m *Model) Owner() names.UserTag {
return names.NewUserTag(m.doc.Owner)
} | [
"func",
"(",
"m",
"*",
"Model",
")",
"Owner",
"(",
")",
"names",
".",
"UserTag",
"{",
"return",
"names",
".",
"NewUserTag",
"(",
"m",
".",
"doc",
".",
"Owner",
")",
"\n",
"}"
] | // Owner returns tag representing the owner of the model.
// The owner is the user that created the model. | [
"Owner",
"returns",
"tag",
"representing",
"the",
"owner",
"of",
"the",
"model",
".",
"The",
"owner",
"is",
"the",
"user",
"that",
"created",
"the",
"model",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L632-L634 |
155,540 | juju/juju | state/model.go | Status | func (m *Model) Status() (status.StatusInfo, error) {
modelStatus, err := getStatus(m.st.db(), m.globalKey(), "model")
if err != nil {
return modelStatus, err
}
return modelStatus, nil
} | go | func (m *Model) Status() (status.StatusInfo, error) {
modelStatus, err := getStatus(m.st.db(), m.globalKey(), "model")
if err != nil {
return modelStatus, err
}
return modelStatus, nil
} | [
"func",
"(",
"m",
"*",
"Model",
")",
"Status",
"(",
")",
"(",
"status",
".",
"StatusInfo",
",",
"error",
")",
"{",
"modelStatus",
",",
"err",
":=",
"getStatus",
"(",
"m",
".",
"st",
".",
"db",
"(",
")",
",",
"m",
".",
"globalKey",
"(",
")",
","... | // Status returns the status of the model. | [
"Status",
"returns",
"the",
"status",
"of",
"the",
"model",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L637-L643 |
155,541 | juju/juju | state/model.go | localID | func (m *Model) localID(ID string) string {
modelUUID, localID, ok := splitDocID(ID)
if !ok || modelUUID != m.doc.UUID {
return ID
}
return localID
} | go | func (m *Model) localID(ID string) string {
modelUUID, localID, ok := splitDocID(ID)
if !ok || modelUUID != m.doc.UUID {
return ID
}
return localID
} | [
"func",
"(",
"m",
"*",
"Model",
")",
"localID",
"(",
"ID",
"string",
")",
"string",
"{",
"modelUUID",
",",
"localID",
",",
"ok",
":=",
"splitDocID",
"(",
"ID",
")",
"\n",
"if",
"!",
"ok",
"||",
"modelUUID",
"!=",
"m",
".",
"doc",
".",
"UUID",
"{"... | // localID returns the local id value by stripping off the model uuid prefix
// if it is there. | [
"localID",
"returns",
"the",
"local",
"id",
"value",
"by",
"stripping",
"off",
"the",
"model",
"uuid",
"prefix",
"if",
"it",
"is",
"there",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L647-L653 |
155,542 | juju/juju | state/model.go | SetSLA | func (m *Model) SetSLA(level, owner string, credentials []byte) error {
l, err := newSLALevel(level)
if err != nil {
return errors.Trace(err)
}
ops := []txn.Op{{
C: modelsC,
Id: m.doc.UUID,
Update: bson.D{{"$set", bson.D{{"sla", slaDoc{
Level: l,
Owner: owner,
Credentials: credentials,
}}}}},
}}
err = m.st.db().RunTransaction(ops)
if err != nil {
return errors.Trace(err)
}
return m.Refresh()
} | go | func (m *Model) SetSLA(level, owner string, credentials []byte) error {
l, err := newSLALevel(level)
if err != nil {
return errors.Trace(err)
}
ops := []txn.Op{{
C: modelsC,
Id: m.doc.UUID,
Update: bson.D{{"$set", bson.D{{"sla", slaDoc{
Level: l,
Owner: owner,
Credentials: credentials,
}}}}},
}}
err = m.st.db().RunTransaction(ops)
if err != nil {
return errors.Trace(err)
}
return m.Refresh()
} | [
"func",
"(",
"m",
"*",
"Model",
")",
"SetSLA",
"(",
"level",
",",
"owner",
"string",
",",
"credentials",
"[",
"]",
"byte",
")",
"error",
"{",
"l",
",",
"err",
":=",
"newSLALevel",
"(",
"level",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
... | // SetSLA sets the SLA on the model. | [
"SetSLA",
"sets",
"the",
"SLA",
"on",
"the",
"model",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L741-L760 |
155,543 | juju/juju | state/model.go | SetMeterStatus | func (m *Model) SetMeterStatus(status, info string) error {
if _, err := isValidMeterStatusCode(status); err != nil {
return errors.Trace(err)
}
ops := []txn.Op{{
C: modelsC,
Id: m.doc.UUID,
Update: bson.D{{"$set", bson.D{{"meter-status", modelMeterStatusdoc{
Code: status,
Info: info,
}}}}},
}}
err := m.st.db().RunTransaction(ops)
if err != nil {
return errors.Trace(err)
}
return m.Refresh()
} | go | func (m *Model) SetMeterStatus(status, info string) error {
if _, err := isValidMeterStatusCode(status); err != nil {
return errors.Trace(err)
}
ops := []txn.Op{{
C: modelsC,
Id: m.doc.UUID,
Update: bson.D{{"$set", bson.D{{"meter-status", modelMeterStatusdoc{
Code: status,
Info: info,
}}}}},
}}
err := m.st.db().RunTransaction(ops)
if err != nil {
return errors.Trace(err)
}
return m.Refresh()
} | [
"func",
"(",
"m",
"*",
"Model",
")",
"SetMeterStatus",
"(",
"status",
",",
"info",
"string",
")",
"error",
"{",
"if",
"_",
",",
"err",
":=",
"isValidMeterStatusCode",
"(",
"status",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Trace",
... | // SetMeterStatus sets the current meter status for this model. | [
"SetMeterStatus",
"sets",
"the",
"current",
"meter",
"status",
"for",
"this",
"model",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L763-L780 |
155,544 | juju/juju | state/model.go | MeterStatus | func (m *Model) MeterStatus() MeterStatus {
ms := m.doc.MeterStatus
return MeterStatus{
Code: MeterStatusFromString(ms.Code),
Info: ms.Info,
}
} | go | func (m *Model) MeterStatus() MeterStatus {
ms := m.doc.MeterStatus
return MeterStatus{
Code: MeterStatusFromString(ms.Code),
Info: ms.Info,
}
} | [
"func",
"(",
"m",
"*",
"Model",
")",
"MeterStatus",
"(",
")",
"MeterStatus",
"{",
"ms",
":=",
"m",
".",
"doc",
".",
"MeterStatus",
"\n",
"return",
"MeterStatus",
"{",
"Code",
":",
"MeterStatusFromString",
"(",
"ms",
".",
"Code",
")",
",",
"Info",
":",
... | // MeterStatus returns the current meter status for this model. | [
"MeterStatus",
"returns",
"the",
"current",
"meter",
"status",
"for",
"this",
"model",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L783-L789 |
155,545 | juju/juju | state/model.go | SetEnvironVersion | func (m *Model) SetEnvironVersion(v int) error {
mOrig := m
mCopy := *m
m = &mCopy // copy so we can refresh without affecting the original m
buildTxn := func(attempt int) ([]txn.Op, error) {
if attempt > 0 {
if err := m.Refresh(); err != nil {
return nil, errors.Trace(err)
}
}
if v < m.doc.EnvironVersion {
return nil, errors.Errorf(
"cannot set environ version to %v, which is less than the current version %v",
v, m.doc.EnvironVersion,
)
}
if v == m.doc.EnvironVersion {
return nil, jujutxn.ErrNoOperations
}
return []txn.Op{{
C: modelsC,
Id: m.doc.UUID,
Assert: bson.D{{"environ-version", m.doc.EnvironVersion}},
Update: bson.D{{"$set", bson.D{{"environ-version", v}}}},
}}, nil
}
if err := m.st.db().Run(buildTxn); err != nil {
return errors.Trace(err)
}
mOrig.doc.EnvironVersion = v
return nil
} | go | func (m *Model) SetEnvironVersion(v int) error {
mOrig := m
mCopy := *m
m = &mCopy // copy so we can refresh without affecting the original m
buildTxn := func(attempt int) ([]txn.Op, error) {
if attempt > 0 {
if err := m.Refresh(); err != nil {
return nil, errors.Trace(err)
}
}
if v < m.doc.EnvironVersion {
return nil, errors.Errorf(
"cannot set environ version to %v, which is less than the current version %v",
v, m.doc.EnvironVersion,
)
}
if v == m.doc.EnvironVersion {
return nil, jujutxn.ErrNoOperations
}
return []txn.Op{{
C: modelsC,
Id: m.doc.UUID,
Assert: bson.D{{"environ-version", m.doc.EnvironVersion}},
Update: bson.D{{"$set", bson.D{{"environ-version", v}}}},
}}, nil
}
if err := m.st.db().Run(buildTxn); err != nil {
return errors.Trace(err)
}
mOrig.doc.EnvironVersion = v
return nil
} | [
"func",
"(",
"m",
"*",
"Model",
")",
"SetEnvironVersion",
"(",
"v",
"int",
")",
"error",
"{",
"mOrig",
":=",
"m",
"\n",
"mCopy",
":=",
"*",
"m",
"\n",
"m",
"=",
"&",
"mCopy",
"// copy so we can refresh without affecting the original m",
"\n",
"buildTxn",
":=... | // SetEnvironVersion sets the model's current environ version. The value
// must be monotonically increasing. | [
"SetEnvironVersion",
"sets",
"the",
"model",
"s",
"current",
"environ",
"version",
".",
"The",
"value",
"must",
"be",
"monotonically",
"increasing",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L802-L833 |
155,546 | juju/juju | state/model.go | AllUnits | func (m *Model) AllUnits() ([]*Unit, error) {
coll, closer := m.st.db().GetCollection(unitsC)
defer closer()
docs := []unitDoc{}
err := coll.Find(nil).All(&docs)
if err != nil {
return nil, errors.Annotate(err, "cannot get all units for model")
}
var units []*Unit
for i := range docs {
units = append(units, newUnit(m.st, m.Type(), &docs[i]))
}
return units, nil
} | go | func (m *Model) AllUnits() ([]*Unit, error) {
coll, closer := m.st.db().GetCollection(unitsC)
defer closer()
docs := []unitDoc{}
err := coll.Find(nil).All(&docs)
if err != nil {
return nil, errors.Annotate(err, "cannot get all units for model")
}
var units []*Unit
for i := range docs {
units = append(units, newUnit(m.st, m.Type(), &docs[i]))
}
return units, nil
} | [
"func",
"(",
"m",
"*",
"Model",
")",
"AllUnits",
"(",
")",
"(",
"[",
"]",
"*",
"Unit",
",",
"error",
")",
"{",
"coll",
",",
"closer",
":=",
"m",
".",
"st",
".",
"db",
"(",
")",
".",
"GetCollection",
"(",
"unitsC",
")",
"\n",
"defer",
"closer",
... | // AllUnits returns all units for a model, for all applications. | [
"AllUnits",
"returns",
"all",
"units",
"for",
"a",
"model",
"for",
"all",
"applications",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L855-L869 |
155,547 | juju/juju | state/model.go | AllEndpointBindings | func (m *Model) AllEndpointBindings() ([]ApplicationEndpointBindings, error) {
endpointBindings, closer := m.st.db().GetCollection(endpointBindingsC)
defer closer()
var docs []endpointBindingsDoc
err := endpointBindings.Find(nil).All(&docs)
if err != nil {
return nil, errors.Annotatef(err, "cannot get endpoint bindings")
}
var appEndpointBindings []ApplicationEndpointBindings
for _, doc := range docs {
var applicationName string
applicationKey := m.localID(doc.DocID)
// for each application deployed we have an instance of ApplicationEndpointBindings struct
if strings.HasPrefix(applicationKey, "a#") {
applicationName = applicationKey[2:]
} else {
return nil, errors.NotValidf("application key %v", applicationKey)
}
endpointBindings := ApplicationEndpointBindings{
AppName: applicationName,
Bindings: doc.Bindings,
}
appEndpointBindings = append(appEndpointBindings, endpointBindings)
}
return appEndpointBindings, nil
} | go | func (m *Model) AllEndpointBindings() ([]ApplicationEndpointBindings, error) {
endpointBindings, closer := m.st.db().GetCollection(endpointBindingsC)
defer closer()
var docs []endpointBindingsDoc
err := endpointBindings.Find(nil).All(&docs)
if err != nil {
return nil, errors.Annotatef(err, "cannot get endpoint bindings")
}
var appEndpointBindings []ApplicationEndpointBindings
for _, doc := range docs {
var applicationName string
applicationKey := m.localID(doc.DocID)
// for each application deployed we have an instance of ApplicationEndpointBindings struct
if strings.HasPrefix(applicationKey, "a#") {
applicationName = applicationKey[2:]
} else {
return nil, errors.NotValidf("application key %v", applicationKey)
}
endpointBindings := ApplicationEndpointBindings{
AppName: applicationName,
Bindings: doc.Bindings,
}
appEndpointBindings = append(appEndpointBindings, endpointBindings)
}
return appEndpointBindings, nil
} | [
"func",
"(",
"m",
"*",
"Model",
")",
"AllEndpointBindings",
"(",
")",
"(",
"[",
"]",
"ApplicationEndpointBindings",
",",
"error",
")",
"{",
"endpointBindings",
",",
"closer",
":=",
"m",
".",
"st",
".",
"db",
"(",
")",
".",
"GetCollection",
"(",
"endpoint... | // AllEndpointBindings returns all endpoint->space bindings for every application | [
"AllEndpointBindings",
"returns",
"all",
"endpoint",
"-",
">",
"space",
"bindings",
"for",
"every",
"application"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L878-L906 |
155,548 | juju/juju | state/model.go | Users | func (m *Model) Users() ([]permission.UserAccess, error) {
coll, closer := m.st.db().GetCollection(modelUsersC)
defer closer()
var userDocs []userAccessDoc
err := coll.Find(nil).All(&userDocs)
if err != nil {
return nil, errors.Trace(err)
}
var modelUsers []permission.UserAccess
for _, doc := range userDocs {
// check if the User belonging to this model user has
// been deleted, in this case we should not return it.
userTag := names.NewUserTag(doc.UserName)
if userTag.IsLocal() {
_, err := m.st.User(userTag)
if err != nil {
if _, ok := err.(DeletedUserError); !ok {
// We ignore deleted users for now. So if it is not a
// DeletedUserError we return the error.
return nil, errors.Trace(err)
}
continue
}
}
mu, err := NewModelUserAccess(m.st, doc)
if err != nil {
return nil, errors.Trace(err)
}
modelUsers = append(modelUsers, mu)
}
return modelUsers, nil
} | go | func (m *Model) Users() ([]permission.UserAccess, error) {
coll, closer := m.st.db().GetCollection(modelUsersC)
defer closer()
var userDocs []userAccessDoc
err := coll.Find(nil).All(&userDocs)
if err != nil {
return nil, errors.Trace(err)
}
var modelUsers []permission.UserAccess
for _, doc := range userDocs {
// check if the User belonging to this model user has
// been deleted, in this case we should not return it.
userTag := names.NewUserTag(doc.UserName)
if userTag.IsLocal() {
_, err := m.st.User(userTag)
if err != nil {
if _, ok := err.(DeletedUserError); !ok {
// We ignore deleted users for now. So if it is not a
// DeletedUserError we return the error.
return nil, errors.Trace(err)
}
continue
}
}
mu, err := NewModelUserAccess(m.st, doc)
if err != nil {
return nil, errors.Trace(err)
}
modelUsers = append(modelUsers, mu)
}
return modelUsers, nil
} | [
"func",
"(",
"m",
"*",
"Model",
")",
"Users",
"(",
")",
"(",
"[",
"]",
"permission",
".",
"UserAccess",
",",
"error",
")",
"{",
"coll",
",",
"closer",
":=",
"m",
".",
"st",
".",
"db",
"(",
")",
".",
"GetCollection",
"(",
"modelUsersC",
")",
"\n",... | // Users returns a slice of all users for this model. | [
"Users",
"returns",
"a",
"slice",
"of",
"all",
"users",
"for",
"this",
"model",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L909-L943 |
155,549 | juju/juju | state/model.go | IsControllerModel | func (m *Model) IsControllerModel() bool {
return m.st.controllerModelTag.Id() == m.doc.UUID
} | go | func (m *Model) IsControllerModel() bool {
return m.st.controllerModelTag.Id() == m.doc.UUID
} | [
"func",
"(",
"m",
"*",
"Model",
")",
"IsControllerModel",
"(",
")",
"bool",
"{",
"return",
"m",
".",
"st",
".",
"controllerModelTag",
".",
"Id",
"(",
")",
"==",
"m",
".",
"doc",
".",
"UUID",
"\n",
"}"
] | // IsControllerModel returns a boolean indicating whether
// this model is responsible for running a controller. | [
"IsControllerModel",
"returns",
"a",
"boolean",
"indicating",
"whether",
"this",
"model",
"is",
"responsible",
"for",
"running",
"a",
"controller",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L947-L949 |
155,550 | juju/juju | state/model.go | Destroy | func (m *Model) Destroy(args DestroyModelParams) (err error) {
defer errors.DeferredAnnotatef(&err, "failed to destroy model")
buildTxn := func(attempt int) ([]txn.Op, error) {
// On the first attempt, we assume memory state is recent
// enough to try using...
if attempt != 0 {
// ...but on subsequent attempts, we read fresh environ
// state from the DB. Note that we do *not* refresh the
// original `m` itself, as detailed in doc/hacking-state.txt
if attempt == 1 {
mCopy := *m
m = &mCopy
}
if err := m.Refresh(); err != nil {
return nil, errors.Trace(err)
}
}
ops, err := m.destroyOps(args, false, false)
if err == errModelNotAlive {
return nil, jujutxn.ErrNoOperations
} else if err != nil {
return nil, errors.Trace(err)
}
return ops, nil
}
return m.st.db().Run(buildTxn)
} | go | func (m *Model) Destroy(args DestroyModelParams) (err error) {
defer errors.DeferredAnnotatef(&err, "failed to destroy model")
buildTxn := func(attempt int) ([]txn.Op, error) {
// On the first attempt, we assume memory state is recent
// enough to try using...
if attempt != 0 {
// ...but on subsequent attempts, we read fresh environ
// state from the DB. Note that we do *not* refresh the
// original `m` itself, as detailed in doc/hacking-state.txt
if attempt == 1 {
mCopy := *m
m = &mCopy
}
if err := m.Refresh(); err != nil {
return nil, errors.Trace(err)
}
}
ops, err := m.destroyOps(args, false, false)
if err == errModelNotAlive {
return nil, jujutxn.ErrNoOperations
} else if err != nil {
return nil, errors.Trace(err)
}
return ops, nil
}
return m.st.db().Run(buildTxn)
} | [
"func",
"(",
"m",
"*",
"Model",
")",
"Destroy",
"(",
"args",
"DestroyModelParams",
")",
"(",
"err",
"error",
")",
"{",
"defer",
"errors",
".",
"DeferredAnnotatef",
"(",
"&",
"err",
",",
"\"",
"\"",
")",
"\n\n",
"buildTxn",
":=",
"func",
"(",
"attempt",... | // Destroy sets the models's lifecycle to Dying, preventing
// addition of applications or machines to state. If called on
// an empty hosted model, the lifecycle will be advanced
// straight to Dead. | [
"Destroy",
"sets",
"the",
"models",
"s",
"lifecycle",
"to",
"Dying",
"preventing",
"addition",
"of",
"applications",
"or",
"machines",
"to",
"state",
".",
"If",
"called",
"on",
"an",
"empty",
"hosted",
"model",
"the",
"lifecycle",
"will",
"be",
"advanced",
"... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L996-L1024 |
155,551 | juju/juju | state/model.go | IsHasHostedModelsError | func IsHasHostedModelsError(err error) bool {
_, ok := errors.Cause(err).(hasHostedModelsError)
return ok
} | go | func IsHasHostedModelsError(err error) bool {
_, ok := errors.Cause(err).(hasHostedModelsError)
return ok
} | [
"func",
"IsHasHostedModelsError",
"(",
"err",
"error",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"errors",
".",
"Cause",
"(",
"err",
")",
".",
"(",
"hasHostedModelsError",
")",
"\n",
"return",
"ok",
"\n",
"}"
] | // IsHasHostedModelsError reports whether or not the given error
// was caused by an attempt to destroy the controller model while
// it contained non-empty hosted models, without specifying that
// they should also be destroyed. | [
"IsHasHostedModelsError",
"reports",
"whether",
"or",
"not",
"the",
"given",
"error",
"was",
"caused",
"by",
"an",
"attempt",
"to",
"destroy",
"the",
"controller",
"model",
"while",
"it",
"contained",
"non",
"-",
"empty",
"hosted",
"models",
"without",
"specifyi... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L1044-L1047 |
155,552 | juju/juju | state/model.go | IsModelNotEmptyError | func IsModelNotEmptyError(err error) bool {
_, ok := errors.Cause(err).(modelNotEmptyError)
return ok
} | go | func IsModelNotEmptyError(err error) bool {
_, ok := errors.Cause(err).(modelNotEmptyError)
return ok
} | [
"func",
"IsModelNotEmptyError",
"(",
"err",
"error",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"errors",
".",
"Cause",
"(",
"err",
")",
".",
"(",
"modelNotEmptyError",
")",
"\n",
"return",
"ok",
"\n",
"}"
] | // IsModelNotEmptyError reports whether or not the given error was caused
// due to an operation requiring a model to be empty, where the model is
// non-empty. | [
"IsModelNotEmptyError",
"reports",
"whether",
"or",
"not",
"the",
"given",
"error",
"was",
"caused",
"due",
"to",
"an",
"operation",
"requiring",
"a",
"model",
"to",
"be",
"empty",
"where",
"the",
"model",
"is",
"non",
"-",
"empty",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L1100-L1103 |
155,553 | juju/juju | state/model.go | getEntityRefs | func (m *Model) getEntityRefs() (*modelEntityRefsDoc, error) {
modelEntityRefs, closer := m.st.db().GetCollection(modelEntityRefsC)
defer closer()
var doc modelEntityRefsDoc
if err := modelEntityRefs.FindId(m.UUID()).One(&doc); err != nil {
if err == mgo.ErrNotFound {
return nil, errors.NotFoundf("entity references doc for model %s", m.UUID())
}
return nil, errors.Annotatef(err, "getting entity references for model %s", m.UUID())
}
return &doc, nil
} | go | func (m *Model) getEntityRefs() (*modelEntityRefsDoc, error) {
modelEntityRefs, closer := m.st.db().GetCollection(modelEntityRefsC)
defer closer()
var doc modelEntityRefsDoc
if err := modelEntityRefs.FindId(m.UUID()).One(&doc); err != nil {
if err == mgo.ErrNotFound {
return nil, errors.NotFoundf("entity references doc for model %s", m.UUID())
}
return nil, errors.Annotatef(err, "getting entity references for model %s", m.UUID())
}
return &doc, nil
} | [
"func",
"(",
"m",
"*",
"Model",
")",
"getEntityRefs",
"(",
")",
"(",
"*",
"modelEntityRefsDoc",
",",
"error",
")",
"{",
"modelEntityRefs",
",",
"closer",
":=",
"m",
".",
"st",
".",
"db",
"(",
")",
".",
"GetCollection",
"(",
"modelEntityRefsC",
")",
"\n... | // getEntityRefs reads the current model entity refs document for the model. | [
"getEntityRefs",
"reads",
"the",
"current",
"model",
"entity",
"refs",
"document",
"for",
"the",
"model",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L1332-L1344 |
155,554 | juju/juju | state/model.go | checkModelEntityRefsEmpty | func checkModelEntityRefsEmpty(doc *modelEntityRefsDoc) ([]txn.Op, error) {
// These errors could be potentially swallowed as we re-try to destroy model.
// Let's, at least, log them for observation.
err := modelNotEmptyError{
machines: len(doc.Machines),
applications: len(doc.Applications),
volumes: len(doc.Volumes),
filesystems: len(doc.Filesystems),
}
if err != (modelNotEmptyError{}) {
return nil, err
}
isEmpty := func(attribute string) bson.DocElem {
// We consider it empty if the array has no entries, or if the attribute doesn't exist
return bson.DocElem{
"$or", []bson.M{{
attribute: bson.M{"$exists": false},
}, {
attribute: bson.M{"$size": 0},
}},
}
}
return []txn.Op{{
C: modelEntityRefsC,
Id: doc.UUID,
Assert: bson.D{
isEmpty("machines"),
isEmpty("applications"),
isEmpty("volumes"),
isEmpty("filesystems"),
},
}}, nil
} | go | func checkModelEntityRefsEmpty(doc *modelEntityRefsDoc) ([]txn.Op, error) {
// These errors could be potentially swallowed as we re-try to destroy model.
// Let's, at least, log them for observation.
err := modelNotEmptyError{
machines: len(doc.Machines),
applications: len(doc.Applications),
volumes: len(doc.Volumes),
filesystems: len(doc.Filesystems),
}
if err != (modelNotEmptyError{}) {
return nil, err
}
isEmpty := func(attribute string) bson.DocElem {
// We consider it empty if the array has no entries, or if the attribute doesn't exist
return bson.DocElem{
"$or", []bson.M{{
attribute: bson.M{"$exists": false},
}, {
attribute: bson.M{"$size": 0},
}},
}
}
return []txn.Op{{
C: modelEntityRefsC,
Id: doc.UUID,
Assert: bson.D{
isEmpty("machines"),
isEmpty("applications"),
isEmpty("volumes"),
isEmpty("filesystems"),
},
}}, nil
} | [
"func",
"checkModelEntityRefsEmpty",
"(",
"doc",
"*",
"modelEntityRefsDoc",
")",
"(",
"[",
"]",
"txn",
".",
"Op",
",",
"error",
")",
"{",
"// These errors could be potentially swallowed as we re-try to destroy model.",
"// Let's, at least, log them for observation.",
"err",
"... | // checkModelEntityRefsEmpty checks that the model is empty of any entities
// that may require external resource cleanup. If the model is not empty,
// then an error will be returned; otherwise txn.Ops are returned to assert
// the continued emptiness. | [
"checkModelEntityRefsEmpty",
"checks",
"that",
"the",
"model",
"is",
"empty",
"of",
"any",
"entities",
"that",
"may",
"require",
"external",
"resource",
"cleanup",
".",
"If",
"the",
"model",
"is",
"not",
"empty",
"then",
"an",
"error",
"will",
"be",
"returned"... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L1356-L1390 |
155,555 | juju/juju | state/model.go | checkModelEntityRefsNoPersistentStorage | func checkModelEntityRefsNoPersistentStorage(
db Database, doc *modelEntityRefsDoc,
) ([]txn.Op, error) {
for _, volumeId := range doc.Volumes {
volumeTag := names.NewVolumeTag(volumeId)
detachable, err := isDetachableVolumeTag(db, volumeTag)
if err != nil {
return nil, errors.Trace(err)
}
if detachable {
return nil, hasPersistentStorageError{}
}
}
for _, filesystemId := range doc.Filesystems {
filesystemTag := names.NewFilesystemTag(filesystemId)
detachable, err := isDetachableFilesystemTag(db, filesystemTag)
if err != nil {
return nil, errors.Trace(err)
}
if detachable {
return nil, hasPersistentStorageError{}
}
}
return noNewStorageModelEntityRefs(doc), nil
} | go | func checkModelEntityRefsNoPersistentStorage(
db Database, doc *modelEntityRefsDoc,
) ([]txn.Op, error) {
for _, volumeId := range doc.Volumes {
volumeTag := names.NewVolumeTag(volumeId)
detachable, err := isDetachableVolumeTag(db, volumeTag)
if err != nil {
return nil, errors.Trace(err)
}
if detachable {
return nil, hasPersistentStorageError{}
}
}
for _, filesystemId := range doc.Filesystems {
filesystemTag := names.NewFilesystemTag(filesystemId)
detachable, err := isDetachableFilesystemTag(db, filesystemTag)
if err != nil {
return nil, errors.Trace(err)
}
if detachable {
return nil, hasPersistentStorageError{}
}
}
return noNewStorageModelEntityRefs(doc), nil
} | [
"func",
"checkModelEntityRefsNoPersistentStorage",
"(",
"db",
"Database",
",",
"doc",
"*",
"modelEntityRefsDoc",
",",
")",
"(",
"[",
"]",
"txn",
".",
"Op",
",",
"error",
")",
"{",
"for",
"_",
",",
"volumeId",
":=",
"range",
"doc",
".",
"Volumes",
"{",
"v... | // checkModelEntityRefsNoPersistentStorage checks that there is no
// persistent storage in the model. If there is, then an error of
// type hasPersistentStorageError is returned. If there is not,
// txn.Ops are returned to assert the same. | [
"checkModelEntityRefsNoPersistentStorage",
"checks",
"that",
"there",
"is",
"no",
"persistent",
"storage",
"in",
"the",
"model",
".",
"If",
"there",
"is",
"then",
"an",
"error",
"of",
"type",
"hasPersistentStorageError",
"is",
"returned",
".",
"If",
"there",
"is",... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L1396-L1420 |
155,556 | juju/juju | state/model.go | checkModelEntityRefsAllReleasableStorage | func checkModelEntityRefsAllReleasableStorage(sb *storageBackend, doc *modelEntityRefsDoc) ([]txn.Op, error) {
for _, volumeId := range doc.Volumes {
volumeTag := names.NewVolumeTag(volumeId)
volume, err := getVolumeByTag(sb.mb, volumeTag)
if err != nil {
return nil, errors.Trace(err)
}
if !volume.Detachable() {
continue
}
if err := checkStoragePoolReleasable(sb, volume.pool()); err != nil {
return nil, errors.Annotatef(err,
"cannot release %s", names.ReadableString(volumeTag),
)
}
}
for _, filesystemId := range doc.Filesystems {
filesystemTag := names.NewFilesystemTag(filesystemId)
filesystem, err := getFilesystemByTag(sb.mb, filesystemTag)
if err != nil {
return nil, errors.Trace(err)
}
if !filesystem.Detachable() {
continue
}
if err := checkStoragePoolReleasable(sb, filesystem.pool()); err != nil {
return nil, errors.Annotatef(err,
"cannot release %s", names.ReadableString(filesystemTag),
)
}
}
return noNewStorageModelEntityRefs(doc), nil
} | go | func checkModelEntityRefsAllReleasableStorage(sb *storageBackend, doc *modelEntityRefsDoc) ([]txn.Op, error) {
for _, volumeId := range doc.Volumes {
volumeTag := names.NewVolumeTag(volumeId)
volume, err := getVolumeByTag(sb.mb, volumeTag)
if err != nil {
return nil, errors.Trace(err)
}
if !volume.Detachable() {
continue
}
if err := checkStoragePoolReleasable(sb, volume.pool()); err != nil {
return nil, errors.Annotatef(err,
"cannot release %s", names.ReadableString(volumeTag),
)
}
}
for _, filesystemId := range doc.Filesystems {
filesystemTag := names.NewFilesystemTag(filesystemId)
filesystem, err := getFilesystemByTag(sb.mb, filesystemTag)
if err != nil {
return nil, errors.Trace(err)
}
if !filesystem.Detachable() {
continue
}
if err := checkStoragePoolReleasable(sb, filesystem.pool()); err != nil {
return nil, errors.Annotatef(err,
"cannot release %s", names.ReadableString(filesystemTag),
)
}
}
return noNewStorageModelEntityRefs(doc), nil
} | [
"func",
"checkModelEntityRefsAllReleasableStorage",
"(",
"sb",
"*",
"storageBackend",
",",
"doc",
"*",
"modelEntityRefsDoc",
")",
"(",
"[",
"]",
"txn",
".",
"Op",
",",
"error",
")",
"{",
"for",
"_",
",",
"volumeId",
":=",
"range",
"doc",
".",
"Volumes",
"{... | // checkModelEntityRefsAllReleasableStorage checks that there all
// persistent storage in the model is releasable. If it is, then
// txn.Ops are returned to assert the same; if it is not, then an
// error is returned. | [
"checkModelEntityRefsAllReleasableStorage",
"checks",
"that",
"there",
"all",
"persistent",
"storage",
"in",
"the",
"model",
"is",
"releasable",
".",
"If",
"it",
"is",
"then",
"txn",
".",
"Ops",
"are",
"returned",
"to",
"assert",
"the",
"same",
";",
"if",
"it"... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L1426-L1458 |
155,557 | juju/juju | state/model.go | createModelOp | func createModelOp(
modelType ModelType,
owner names.UserTag,
name, uuid, controllerUUID, cloudName, cloudRegion string,
cloudCredential names.CloudCredentialTag,
migrationMode MigrationMode,
environVersion int,
) txn.Op {
doc := &modelDoc{
Type: modelType,
UUID: uuid,
Name: name,
Life: Alive,
Owner: owner.Id(),
ControllerUUID: controllerUUID,
MigrationMode: migrationMode,
EnvironVersion: environVersion,
Cloud: cloudName,
CloudRegion: cloudRegion,
CloudCredential: cloudCredential.Id(),
}
return txn.Op{
C: modelsC,
Id: uuid,
Assert: txn.DocMissing,
Insert: doc,
}
} | go | func createModelOp(
modelType ModelType,
owner names.UserTag,
name, uuid, controllerUUID, cloudName, cloudRegion string,
cloudCredential names.CloudCredentialTag,
migrationMode MigrationMode,
environVersion int,
) txn.Op {
doc := &modelDoc{
Type: modelType,
UUID: uuid,
Name: name,
Life: Alive,
Owner: owner.Id(),
ControllerUUID: controllerUUID,
MigrationMode: migrationMode,
EnvironVersion: environVersion,
Cloud: cloudName,
CloudRegion: cloudRegion,
CloudCredential: cloudCredential.Id(),
}
return txn.Op{
C: modelsC,
Id: uuid,
Assert: txn.DocMissing,
Insert: doc,
}
} | [
"func",
"createModelOp",
"(",
"modelType",
"ModelType",
",",
"owner",
"names",
".",
"UserTag",
",",
"name",
",",
"uuid",
",",
"controllerUUID",
",",
"cloudName",
",",
"cloudRegion",
"string",
",",
"cloudCredential",
"names",
".",
"CloudCredentialTag",
",",
"migr... | // createModelOp returns the operation needed to create
// an model document with the given name and UUID. | [
"createModelOp",
"returns",
"the",
"operation",
"needed",
"to",
"create",
"an",
"model",
"document",
"with",
"the",
"given",
"name",
"and",
"UUID",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L1544-L1571 |
155,558 | juju/juju | state/model.go | createUniqueOwnerModelNameOp | func createUniqueOwnerModelNameOp(qualifier string, modelName string) txn.Op {
return txn.Op{
C: usermodelnameC,
Id: userModelNameIndex(qualifier, modelName),
Assert: txn.DocMissing,
Insert: bson.M{},
}
} | go | func createUniqueOwnerModelNameOp(qualifier string, modelName string) txn.Op {
return txn.Op{
C: usermodelnameC,
Id: userModelNameIndex(qualifier, modelName),
Assert: txn.DocMissing,
Insert: bson.M{},
}
} | [
"func",
"createUniqueOwnerModelNameOp",
"(",
"qualifier",
"string",
",",
"modelName",
"string",
")",
"txn",
".",
"Op",
"{",
"return",
"txn",
".",
"Op",
"{",
"C",
":",
"usermodelnameC",
",",
"Id",
":",
"userModelNameIndex",
"(",
"qualifier",
",",
"modelName",
... | // createUniqueOwnerModelNameOp returns the operation needed to create
// an usermodelnameC document with the given qualifier and model name. | [
"createUniqueOwnerModelNameOp",
"returns",
"the",
"operation",
"needed",
"to",
"create",
"an",
"usermodelnameC",
"document",
"with",
"the",
"given",
"qualifier",
"and",
"model",
"name",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L1630-L1637 |
155,559 | juju/juju | state/model.go | assertModelActiveOp | func assertModelActiveOp(modelUUID string) txn.Op {
return txn.Op{
C: modelsC,
Id: modelUUID,
Assert: append(isAliveDoc, bson.DocElem{"migration-mode", MigrationModeNone}),
}
} | go | func assertModelActiveOp(modelUUID string) txn.Op {
return txn.Op{
C: modelsC,
Id: modelUUID,
Assert: append(isAliveDoc, bson.DocElem{"migration-mode", MigrationModeNone}),
}
} | [
"func",
"assertModelActiveOp",
"(",
"modelUUID",
"string",
")",
"txn",
".",
"Op",
"{",
"return",
"txn",
".",
"Op",
"{",
"C",
":",
"modelsC",
",",
"Id",
":",
"modelUUID",
",",
"Assert",
":",
"append",
"(",
"isAliveDoc",
",",
"bson",
".",
"DocElem",
"{",... | // assertModelActiveOp returns a txn.Op that asserts the given
// model UUID refers to an Alive model. | [
"assertModelActiveOp",
"returns",
"a",
"txn",
".",
"Op",
"that",
"asserts",
"the",
"given",
"model",
"UUID",
"refers",
"to",
"an",
"Alive",
"model",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/state/model.go#L1646-L1652 |
155,560 | juju/juju | cmd/juju/application/consume.go | Run | func (c *consumeCommand) Run(ctx *cmd.Context) error {
accountDetails, err := c.CurrentAccountDetails()
if err != nil {
return errors.Trace(err)
}
url, err := crossmodel.ParseOfferURL(c.remoteApplication)
if err != nil {
return errors.Trace(err)
}
if url.HasEndpoint() {
return errors.Errorf("remote offer %q shouldn't include endpoint", c.remoteApplication)
}
if url.User == "" {
url.User = accountDetails.User
c.remoteApplication = url.Path()
}
sourceClient, err := c.getSourceAPI(url)
if err != nil {
return errors.Trace(err)
}
defer sourceClient.Close()
consumeDetails, err := sourceClient.GetConsumeDetails(url.AsLocal().String())
if err != nil {
return errors.Trace(err)
}
// Parse the offer details URL and add the source controller so
// things like status can show the original source of the offer.
offerURL, err := crossmodel.ParseOfferURL(consumeDetails.Offer.OfferURL)
if err != nil {
return errors.Trace(err)
}
offerURL.Source = url.Source
consumeDetails.Offer.OfferURL = offerURL.String()
targetClient, err := c.getTargetAPI()
if err != nil {
return errors.Trace(err)
}
defer targetClient.Close()
arg := crossmodel.ConsumeApplicationArgs{
Offer: *consumeDetails.Offer,
ApplicationAlias: c.applicationAlias,
Macaroon: consumeDetails.Macaroon,
}
if consumeDetails.ControllerInfo != nil {
controllerTag, err := names.ParseControllerTag(consumeDetails.ControllerInfo.ControllerTag)
if err != nil {
return errors.Trace(err)
}
arg.ControllerInfo = &crossmodel.ControllerInfo{
ControllerTag: controllerTag,
Alias: consumeDetails.ControllerInfo.Alias,
Addrs: consumeDetails.ControllerInfo.Addrs,
CACert: consumeDetails.ControllerInfo.CACert,
}
}
localName, err := targetClient.Consume(arg)
if err != nil {
return errors.Trace(err)
}
ctx.Infof("Added %s as %s", c.remoteApplication, localName)
return nil
} | go | func (c *consumeCommand) Run(ctx *cmd.Context) error {
accountDetails, err := c.CurrentAccountDetails()
if err != nil {
return errors.Trace(err)
}
url, err := crossmodel.ParseOfferURL(c.remoteApplication)
if err != nil {
return errors.Trace(err)
}
if url.HasEndpoint() {
return errors.Errorf("remote offer %q shouldn't include endpoint", c.remoteApplication)
}
if url.User == "" {
url.User = accountDetails.User
c.remoteApplication = url.Path()
}
sourceClient, err := c.getSourceAPI(url)
if err != nil {
return errors.Trace(err)
}
defer sourceClient.Close()
consumeDetails, err := sourceClient.GetConsumeDetails(url.AsLocal().String())
if err != nil {
return errors.Trace(err)
}
// Parse the offer details URL and add the source controller so
// things like status can show the original source of the offer.
offerURL, err := crossmodel.ParseOfferURL(consumeDetails.Offer.OfferURL)
if err != nil {
return errors.Trace(err)
}
offerURL.Source = url.Source
consumeDetails.Offer.OfferURL = offerURL.String()
targetClient, err := c.getTargetAPI()
if err != nil {
return errors.Trace(err)
}
defer targetClient.Close()
arg := crossmodel.ConsumeApplicationArgs{
Offer: *consumeDetails.Offer,
ApplicationAlias: c.applicationAlias,
Macaroon: consumeDetails.Macaroon,
}
if consumeDetails.ControllerInfo != nil {
controllerTag, err := names.ParseControllerTag(consumeDetails.ControllerInfo.ControllerTag)
if err != nil {
return errors.Trace(err)
}
arg.ControllerInfo = &crossmodel.ControllerInfo{
ControllerTag: controllerTag,
Alias: consumeDetails.ControllerInfo.Alias,
Addrs: consumeDetails.ControllerInfo.Addrs,
CACert: consumeDetails.ControllerInfo.CACert,
}
}
localName, err := targetClient.Consume(arg)
if err != nil {
return errors.Trace(err)
}
ctx.Infof("Added %s as %s", c.remoteApplication, localName)
return nil
} | [
"func",
"(",
"c",
"*",
"consumeCommand",
")",
"Run",
"(",
"ctx",
"*",
"cmd",
".",
"Context",
")",
"error",
"{",
"accountDetails",
",",
"err",
":=",
"c",
".",
"CurrentAccountDetails",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
... | // Run adds the requested remote offer to the model. Implements
// cmd.Command. | [
"Run",
"adds",
"the",
"requested",
"remote",
"offer",
"to",
"the",
"model",
".",
"Implements",
"cmd",
".",
"Command",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/application/consume.go#L113-L177 |
155,561 | juju/juju | worker/uniter/runner/debug/server.go | MatchHook | func (s *ServerSession) MatchHook(hookName string) bool {
return s.hooks.IsEmpty() || s.hooks.Contains(hookName)
} | go | func (s *ServerSession) MatchHook(hookName string) bool {
return s.hooks.IsEmpty() || s.hooks.Contains(hookName)
} | [
"func",
"(",
"s",
"*",
"ServerSession",
")",
"MatchHook",
"(",
"hookName",
"string",
")",
"bool",
"{",
"return",
"s",
".",
"hooks",
".",
"IsEmpty",
"(",
")",
"||",
"s",
".",
"hooks",
".",
"Contains",
"(",
"hookName",
")",
"\n",
"}"
] | // MatchHook returns true if the specified hook name matches
// the hook specified by the debug-hooks client. | [
"MatchHook",
"returns",
"true",
"if",
"the",
"specified",
"hook",
"name",
"matches",
"the",
"hook",
"specified",
"by",
"the",
"debug",
"-",
"hooks",
"client",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/uniter/runner/debug/server.go#L31-L33 |
155,562 | juju/juju | worker/uniter/runner/debug/server.go | RunHook | func (s *ServerSession) RunHook(hookName, charmDir string, env []string) error {
debugDir, err := ioutil.TempDir("", "juju-debug-hooks-")
if err != nil {
return errors.Trace(err)
}
defer os.RemoveAll(debugDir)
if err := s.writeDebugFiles(debugDir); err != nil {
return errors.Trace(err)
}
env = utils.Setenv(env, "JUJU_HOOK_NAME="+hookName)
env = utils.Setenv(env, "JUJU_DEBUG="+debugDir)
cmd := exec.Command("/bin/bash", "-s")
cmd.Env = env
cmd.Dir = charmDir
cmd.Stdin = bytes.NewBufferString(debugHooksServerScript)
if s.output != nil {
cmd.Stdout = s.output
cmd.Stderr = s.output
}
if err := cmd.Start(); err != nil {
return err
}
go func(proc *os.Process) {
// Wait for the SSH client to exit (i.e. release the flock),
// then kill the server hook process in case the client
// exited uncleanly.
waitClientExit(s)
proc.Kill()
}(cmd.Process)
return cmd.Wait()
} | go | func (s *ServerSession) RunHook(hookName, charmDir string, env []string) error {
debugDir, err := ioutil.TempDir("", "juju-debug-hooks-")
if err != nil {
return errors.Trace(err)
}
defer os.RemoveAll(debugDir)
if err := s.writeDebugFiles(debugDir); err != nil {
return errors.Trace(err)
}
env = utils.Setenv(env, "JUJU_HOOK_NAME="+hookName)
env = utils.Setenv(env, "JUJU_DEBUG="+debugDir)
cmd := exec.Command("/bin/bash", "-s")
cmd.Env = env
cmd.Dir = charmDir
cmd.Stdin = bytes.NewBufferString(debugHooksServerScript)
if s.output != nil {
cmd.Stdout = s.output
cmd.Stderr = s.output
}
if err := cmd.Start(); err != nil {
return err
}
go func(proc *os.Process) {
// Wait for the SSH client to exit (i.e. release the flock),
// then kill the server hook process in case the client
// exited uncleanly.
waitClientExit(s)
proc.Kill()
}(cmd.Process)
return cmd.Wait()
} | [
"func",
"(",
"s",
"*",
"ServerSession",
")",
"RunHook",
"(",
"hookName",
",",
"charmDir",
"string",
",",
"env",
"[",
"]",
"string",
")",
"error",
"{",
"debugDir",
",",
"err",
":=",
"ioutil",
".",
"TempDir",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\... | // RunHook "runs" the hook with the specified name via debug-hooks. | [
"RunHook",
"runs",
"the",
"hook",
"with",
"the",
"specified",
"name",
"via",
"debug",
"-",
"hooks",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/uniter/runner/debug/server.go#L43-L75 |
155,563 | juju/juju | worker/uniter/runner/debug/server.go | FindSession | func (c *HooksContext) FindSession() (*ServerSession, error) {
cmd := exec.Command("tmux", "has-session", "-t", c.tmuxSessionName())
out, err := cmd.CombinedOutput()
if err != nil {
if len(out) != 0 {
return nil, errors.New(string(out))
} else {
return nil, err
}
}
// Parse the debug-hooks file for an optional hook name.
data, err := ioutil.ReadFile(c.ClientFileLock())
if err != nil {
return nil, err
}
var args hookArgs
err = goyaml.Unmarshal(data, &args)
if err != nil {
return nil, err
}
hooks := set.NewStrings(args.Hooks...)
session := &ServerSession{HooksContext: c, hooks: hooks}
return session, nil
} | go | func (c *HooksContext) FindSession() (*ServerSession, error) {
cmd := exec.Command("tmux", "has-session", "-t", c.tmuxSessionName())
out, err := cmd.CombinedOutput()
if err != nil {
if len(out) != 0 {
return nil, errors.New(string(out))
} else {
return nil, err
}
}
// Parse the debug-hooks file for an optional hook name.
data, err := ioutil.ReadFile(c.ClientFileLock())
if err != nil {
return nil, err
}
var args hookArgs
err = goyaml.Unmarshal(data, &args)
if err != nil {
return nil, err
}
hooks := set.NewStrings(args.Hooks...)
session := &ServerSession{HooksContext: c, hooks: hooks}
return session, nil
} | [
"func",
"(",
"c",
"*",
"HooksContext",
")",
"FindSession",
"(",
")",
"(",
"*",
"ServerSession",
",",
"error",
")",
"{",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"c",
".",
"tmuxSessionName",
"(",
... | // FindSession attempts to find a debug hooks session for the unit specified
// in the context, and returns a new ServerSession structure for it. | [
"FindSession",
"attempts",
"to",
"find",
"a",
"debug",
"hooks",
"session",
"for",
"the",
"unit",
"specified",
"in",
"the",
"context",
"and",
"returns",
"a",
"new",
"ServerSession",
"structure",
"for",
"it",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/worker/uniter/runner/debug/server.go#L110-L133 |
155,564 | juju/juju | environs/manual/sshprovisioner/sshprovisioner.go | gatherMachineParams | func gatherMachineParams(hostname string) (*params.AddMachineParams, error) {
// Generate a unique nonce for the machine.
uuid, err := utils.NewUUID()
if err != nil {
return nil, err
}
addr, err := manual.HostAddress(hostname)
if err != nil {
return nil, errors.Annotatef(err, "failed to compute public address for %q", hostname)
}
provisioned, err := checkProvisioned(hostname)
if err != nil {
return nil, errors.Annotatef(err, "error checking if provisioned")
}
if provisioned {
return nil, manual.ErrProvisioned
}
hc, series, err := DetectSeriesAndHardwareCharacteristics(hostname)
if err != nil {
return nil, errors.Annotatef(err, "error detecting linux hardware characteristics")
}
// There will never be a corresponding "instance" that any provider
// knows about. This is fine, and works well with the provisioner
// task. The provisioner task will happily remove any and all dead
// machines from state, but will ignore the associated instance ID
// if it isn't one that the environment provider knows about.
instanceId := instance.Id(manual.ManualInstancePrefix + hostname)
nonce := fmt.Sprintf("%s:%s", instanceId, uuid.String())
machineParams := ¶ms.AddMachineParams{
Series: series,
HardwareCharacteristics: hc,
InstanceId: instanceId,
Nonce: nonce,
Addrs: params.FromNetworkAddresses(addr),
Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
}
return machineParams, nil
} | go | func gatherMachineParams(hostname string) (*params.AddMachineParams, error) {
// Generate a unique nonce for the machine.
uuid, err := utils.NewUUID()
if err != nil {
return nil, err
}
addr, err := manual.HostAddress(hostname)
if err != nil {
return nil, errors.Annotatef(err, "failed to compute public address for %q", hostname)
}
provisioned, err := checkProvisioned(hostname)
if err != nil {
return nil, errors.Annotatef(err, "error checking if provisioned")
}
if provisioned {
return nil, manual.ErrProvisioned
}
hc, series, err := DetectSeriesAndHardwareCharacteristics(hostname)
if err != nil {
return nil, errors.Annotatef(err, "error detecting linux hardware characteristics")
}
// There will never be a corresponding "instance" that any provider
// knows about. This is fine, and works well with the provisioner
// task. The provisioner task will happily remove any and all dead
// machines from state, but will ignore the associated instance ID
// if it isn't one that the environment provider knows about.
instanceId := instance.Id(manual.ManualInstancePrefix + hostname)
nonce := fmt.Sprintf("%s:%s", instanceId, uuid.String())
machineParams := ¶ms.AddMachineParams{
Series: series,
HardwareCharacteristics: hc,
InstanceId: instanceId,
Nonce: nonce,
Addrs: params.FromNetworkAddresses(addr),
Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
}
return machineParams, nil
} | [
"func",
"gatherMachineParams",
"(",
"hostname",
"string",
")",
"(",
"*",
"params",
".",
"AddMachineParams",
",",
"error",
")",
"{",
"// Generate a unique nonce for the machine.",
"uuid",
",",
"err",
":=",
"utils",
".",
"NewUUID",
"(",
")",
"\n",
"if",
"err",
"... | // gatherMachineParams collects all the information we know about the machine
// we are about to provision. It will SSH into that machine as the ubuntu user.
// The hostname supplied should not include a username.
// If we can, we will reverse lookup the hostname by its IP address, and use
// the DNS resolved name, rather than the name that was supplied | [
"gatherMachineParams",
"collects",
"all",
"the",
"information",
"we",
"know",
"about",
"the",
"machine",
"we",
"are",
"about",
"to",
"provision",
".",
"It",
"will",
"SSH",
"into",
"that",
"machine",
"as",
"the",
"ubuntu",
"user",
".",
"The",
"hostname",
"sup... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/environs/manual/sshprovisioner/sshprovisioner.go#L213-L255 |
155,565 | juju/juju | environs/manual/sshprovisioner/sshprovisioner.go | ProvisioningScript | func ProvisioningScript(icfg *instancecfg.InstanceConfig) (string, error) {
cloudcfg, err := cloudinit.New(icfg.Series)
if err != nil {
return "", errors.Annotate(err, "error generating cloud-config")
}
cloudcfg.SetSystemUpdate(icfg.EnableOSRefreshUpdate)
cloudcfg.SetSystemUpgrade(icfg.EnableOSUpgrade)
udata, err := cloudconfig.NewUserdataConfig(icfg, cloudcfg)
if err != nil {
return "", errors.Annotate(err, "error generating cloud-config")
}
if err := udata.ConfigureJuju(); err != nil {
return "", errors.Annotate(err, "error generating cloud-config")
}
configScript, err := cloudcfg.RenderScript()
if err != nil {
return "", errors.Annotate(err, "error converting cloud-config to script")
}
var buf bytes.Buffer
// Always remove the cloud-init-output.log file first, if it exists.
fmt.Fprintf(&buf, "rm -f %s\n", utils.ShQuote(icfg.CloudInitOutputLog))
// If something goes wrong, dump cloud-init-output.log to stderr.
buf.WriteString(shell.DumpFileOnErrorScript(icfg.CloudInitOutputLog))
buf.WriteString(configScript)
return buf.String(), nil
} | go | func ProvisioningScript(icfg *instancecfg.InstanceConfig) (string, error) {
cloudcfg, err := cloudinit.New(icfg.Series)
if err != nil {
return "", errors.Annotate(err, "error generating cloud-config")
}
cloudcfg.SetSystemUpdate(icfg.EnableOSRefreshUpdate)
cloudcfg.SetSystemUpgrade(icfg.EnableOSUpgrade)
udata, err := cloudconfig.NewUserdataConfig(icfg, cloudcfg)
if err != nil {
return "", errors.Annotate(err, "error generating cloud-config")
}
if err := udata.ConfigureJuju(); err != nil {
return "", errors.Annotate(err, "error generating cloud-config")
}
configScript, err := cloudcfg.RenderScript()
if err != nil {
return "", errors.Annotate(err, "error converting cloud-config to script")
}
var buf bytes.Buffer
// Always remove the cloud-init-output.log file first, if it exists.
fmt.Fprintf(&buf, "rm -f %s\n", utils.ShQuote(icfg.CloudInitOutputLog))
// If something goes wrong, dump cloud-init-output.log to stderr.
buf.WriteString(shell.DumpFileOnErrorScript(icfg.CloudInitOutputLog))
buf.WriteString(configScript)
return buf.String(), nil
} | [
"func",
"ProvisioningScript",
"(",
"icfg",
"*",
"instancecfg",
".",
"InstanceConfig",
")",
"(",
"string",
",",
"error",
")",
"{",
"cloudcfg",
",",
"err",
":=",
"cloudinit",
".",
"New",
"(",
"icfg",
".",
"Series",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{... | // ProvisioningScript generates a bash script that can be
// executed on a remote host to carry out the cloud-init
// configuration. | [
"ProvisioningScript",
"generates",
"a",
"bash",
"script",
"that",
"can",
"be",
"executed",
"on",
"a",
"remote",
"host",
"to",
"carry",
"out",
"the",
"cloud",
"-",
"init",
"configuration",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/environs/manual/sshprovisioner/sshprovisioner.go#L268-L296 |
155,566 | juju/juju | cmd/juju/crossmodel/remove.go | NewRemoveOfferCommand | func NewRemoveOfferCommand() cmd.Command {
removeCmd := &removeCommand{}
removeCmd.newAPIFunc = func(controllerName string) (RemoveAPI, error) {
return removeCmd.NewApplicationOffersAPI(controllerName)
}
return modelcmd.WrapController(removeCmd)
} | go | func NewRemoveOfferCommand() cmd.Command {
removeCmd := &removeCommand{}
removeCmd.newAPIFunc = func(controllerName string) (RemoveAPI, error) {
return removeCmd.NewApplicationOffersAPI(controllerName)
}
return modelcmd.WrapController(removeCmd)
} | [
"func",
"NewRemoveOfferCommand",
"(",
")",
"cmd",
".",
"Command",
"{",
"removeCmd",
":=",
"&",
"removeCommand",
"{",
"}",
"\n",
"removeCmd",
".",
"newAPIFunc",
"=",
"func",
"(",
"controllerName",
"string",
")",
"(",
"RemoveAPI",
",",
"error",
")",
"{",
"re... | // NewRemoveOfferCommand returns a command used to remove a specified offer. | [
"NewRemoveOfferCommand",
"returns",
"a",
"command",
"used",
"to",
"remove",
"a",
"specified",
"offer",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/crossmodel/remove.go#L23-L29 |
155,567 | juju/juju | cmd/juju/crossmodel/remove.go | NewApplicationOffersAPI | func (c *removeCommand) NewApplicationOffersAPI(controllerName string) (*applicationoffers.Client, error) {
root, err := c.CommandBase.NewAPIRoot(c.ClientStore(), controllerName, "")
if err != nil {
return nil, err
}
return applicationoffers.NewClient(root), nil
} | go | func (c *removeCommand) NewApplicationOffersAPI(controllerName string) (*applicationoffers.Client, error) {
root, err := c.CommandBase.NewAPIRoot(c.ClientStore(), controllerName, "")
if err != nil {
return nil, err
}
return applicationoffers.NewClient(root), nil
} | [
"func",
"(",
"c",
"*",
"removeCommand",
")",
"NewApplicationOffersAPI",
"(",
"controllerName",
"string",
")",
"(",
"*",
"applicationoffers",
".",
"Client",
",",
"error",
")",
"{",
"root",
",",
"err",
":=",
"c",
".",
"CommandBase",
".",
"NewAPIRoot",
"(",
"... | // NewApplicationOffersAPI returns an application offers api. | [
"NewApplicationOffersAPI",
"returns",
"an",
"application",
"offers",
"api",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/crossmodel/remove.go#L97-L103 |
155,568 | juju/juju | cmd/juju/block/protection.go | getBlockAPI | func getBlockAPI(c newAPIRoot) (*apiblock.Client, error) {
root, err := c.NewAPIRoot()
if err != nil {
return nil, err
}
return apiblock.NewClient(root), nil
} | go | func getBlockAPI(c newAPIRoot) (*apiblock.Client, error) {
root, err := c.NewAPIRoot()
if err != nil {
return nil, err
}
return apiblock.NewClient(root), nil
} | [
"func",
"getBlockAPI",
"(",
"c",
"newAPIRoot",
")",
"(",
"*",
"apiblock",
".",
"Client",
",",
"error",
")",
"{",
"root",
",",
"err",
":=",
"c",
".",
"NewAPIRoot",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"... | // getBlockAPI returns a block api for block manipulation. | [
"getBlockAPI",
"returns",
"a",
"block",
"api",
"for",
"block",
"manipulation",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/block/protection.go#L58-L64 |
155,569 | juju/juju | cmd/juju/block/protection.go | ProcessBlockedError | func ProcessBlockedError(err error, block Block) error {
if err == nil {
return nil
}
if params.IsCodeOperationBlocked(err) {
msg := fmt.Sprintf("%v\n%v", err, blockedMessages[block])
logger.Infof(msg)
return errors.Errorf(msg)
}
return err
} | go | func ProcessBlockedError(err error, block Block) error {
if err == nil {
return nil
}
if params.IsCodeOperationBlocked(err) {
msg := fmt.Sprintf("%v\n%v", err, blockedMessages[block])
logger.Infof(msg)
return errors.Errorf(msg)
}
return err
} | [
"func",
"ProcessBlockedError",
"(",
"err",
"error",
",",
"block",
"Block",
")",
"error",
"{",
"if",
"err",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"params",
".",
"IsCodeOperationBlocked",
"(",
"err",
")",
"{",
"msg",
":=",
"fmt",
".",... | // ProcessBlockedError ensures that correct and user-friendly message is
// displayed to the user based on the block type. | [
"ProcessBlockedError",
"ensures",
"that",
"correct",
"and",
"user",
"-",
"friendly",
"message",
"is",
"displayed",
"to",
"the",
"user",
"based",
"on",
"the",
"block",
"type",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/block/protection.go#L91-L101 |
155,570 | juju/juju | environs/tools/marshal.go | MarshalToolsMetadataJSON | func MarshalToolsMetadataJSON(metadata map[string][]*ToolsMetadata, updated time.Time) (index, legacyIndex []byte, products map[string][]byte, err error) {
if index, legacyIndex, err = marshalToolsMetadataIndexJSON(metadata, updated); err != nil {
return nil, nil, nil, err
}
if products, err = MarshalToolsMetadataProductsJSON(metadata, updated); err != nil {
return nil, nil, nil, err
}
return index, legacyIndex, products, err
} | go | func MarshalToolsMetadataJSON(metadata map[string][]*ToolsMetadata, updated time.Time) (index, legacyIndex []byte, products map[string][]byte, err error) {
if index, legacyIndex, err = marshalToolsMetadataIndexJSON(metadata, updated); err != nil {
return nil, nil, nil, err
}
if products, err = MarshalToolsMetadataProductsJSON(metadata, updated); err != nil {
return nil, nil, nil, err
}
return index, legacyIndex, products, err
} | [
"func",
"MarshalToolsMetadataJSON",
"(",
"metadata",
"map",
"[",
"string",
"]",
"[",
"]",
"*",
"ToolsMetadata",
",",
"updated",
"time",
".",
"Time",
")",
"(",
"index",
",",
"legacyIndex",
"[",
"]",
"byte",
",",
"products",
"map",
"[",
"string",
"]",
"[",... | // MarshalToolsMetadataJSON marshals tools metadata to index and products JSON.
// updated is the time at which the JSON file was updated. | [
"MarshalToolsMetadataJSON",
"marshals",
"tools",
"metadata",
"to",
"index",
"and",
"products",
"JSON",
".",
"updated",
"is",
"the",
"time",
"at",
"which",
"the",
"JSON",
"file",
"was",
"updated",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/environs/tools/marshal.go#L32-L40 |
155,571 | juju/juju | environs/tools/marshal.go | marshalToolsMetadataIndexJSON | func marshalToolsMetadataIndexJSON(streamMetadata map[string][]*ToolsMetadata, updated time.Time) (out, outlegacy []byte, err error) {
var indices simplestreams.Indices
indices.Updated = updated.Format(time.RFC1123Z)
indices.Format = simplestreams.IndexFormat
indices.Indexes = make(map[string]*simplestreams.IndexMetadata, len(streamMetadata))
var indicesLegacy simplestreams.Indices
indicesLegacy.Updated = updated.Format(time.RFC1123Z)
indicesLegacy.Format = simplestreams.IndexFormat
for stream, metadata := range streamMetadata {
var productIds []string
for _, t := range metadata {
id, err := t.productId()
if err != nil {
if series.IsUnknownSeriesVersionError(err) {
logger.Infof("ignoring tools metadata with unknown series %q", t.Release)
continue
}
return nil, nil, err
}
productIds = append(productIds, id)
}
indexMetadata := &simplestreams.IndexMetadata{
Updated: indices.Updated,
Format: simplestreams.ProductFormat,
DataType: ContentDownload,
ProductsFilePath: ProductMetadataPath(stream),
ProductIds: set.NewStrings(productIds...).SortedValues(),
}
indices.Indexes[ToolsContentId(stream)] = indexMetadata
if stream == ReleasedStream {
indicesLegacy.Indexes = make(map[string]*simplestreams.IndexMetadata, 1)
indicesLegacy.Indexes[ToolsContentId(stream)] = indexMetadata
}
}
out, err = json.MarshalIndent(&indices, "", " ")
if len(indicesLegacy.Indexes) == 0 {
return out, nil, err
}
outlegacy, err = json.MarshalIndent(&indicesLegacy, "", " ")
if err != nil {
return nil, nil, err
}
return out, outlegacy, nil
} | go | func marshalToolsMetadataIndexJSON(streamMetadata map[string][]*ToolsMetadata, updated time.Time) (out, outlegacy []byte, err error) {
var indices simplestreams.Indices
indices.Updated = updated.Format(time.RFC1123Z)
indices.Format = simplestreams.IndexFormat
indices.Indexes = make(map[string]*simplestreams.IndexMetadata, len(streamMetadata))
var indicesLegacy simplestreams.Indices
indicesLegacy.Updated = updated.Format(time.RFC1123Z)
indicesLegacy.Format = simplestreams.IndexFormat
for stream, metadata := range streamMetadata {
var productIds []string
for _, t := range metadata {
id, err := t.productId()
if err != nil {
if series.IsUnknownSeriesVersionError(err) {
logger.Infof("ignoring tools metadata with unknown series %q", t.Release)
continue
}
return nil, nil, err
}
productIds = append(productIds, id)
}
indexMetadata := &simplestreams.IndexMetadata{
Updated: indices.Updated,
Format: simplestreams.ProductFormat,
DataType: ContentDownload,
ProductsFilePath: ProductMetadataPath(stream),
ProductIds: set.NewStrings(productIds...).SortedValues(),
}
indices.Indexes[ToolsContentId(stream)] = indexMetadata
if stream == ReleasedStream {
indicesLegacy.Indexes = make(map[string]*simplestreams.IndexMetadata, 1)
indicesLegacy.Indexes[ToolsContentId(stream)] = indexMetadata
}
}
out, err = json.MarshalIndent(&indices, "", " ")
if len(indicesLegacy.Indexes) == 0 {
return out, nil, err
}
outlegacy, err = json.MarshalIndent(&indicesLegacy, "", " ")
if err != nil {
return nil, nil, err
}
return out, outlegacy, nil
} | [
"func",
"marshalToolsMetadataIndexJSON",
"(",
"streamMetadata",
"map",
"[",
"string",
"]",
"[",
"]",
"*",
"ToolsMetadata",
",",
"updated",
"time",
".",
"Time",
")",
"(",
"out",
",",
"outlegacy",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"var",
"in... | // marshalToolsMetadataIndexJSON marshals tools metadata to index JSON.
// updated is the time at which the JSON file was updated. | [
"marshalToolsMetadataIndexJSON",
"marshals",
"tools",
"metadata",
"to",
"index",
"JSON",
".",
"updated",
"is",
"the",
"time",
"at",
"which",
"the",
"JSON",
"file",
"was",
"updated",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/environs/tools/marshal.go#L44-L89 |
155,572 | juju/juju | environs/tools/marshal.go | MarshalToolsMetadataProductsJSON | func MarshalToolsMetadataProductsJSON(
streamMetadata map[string][]*ToolsMetadata, updated time.Time,
) (out map[string][]byte, err error) {
out = make(map[string][]byte, len(streamMetadata))
for stream, metadata := range streamMetadata {
var cloud simplestreams.CloudMetadata
cloud.Updated = updated.Format(time.RFC1123Z)
cloud.Format = simplestreams.ProductFormat
cloud.ContentId = ToolsContentId(stream)
cloud.Products = make(map[string]simplestreams.MetadataCatalog)
itemsversion := updated.Format("20060102") // YYYYMMDD
for _, t := range metadata {
id, err := t.productId()
if err != nil {
if series.IsUnknownSeriesVersionError(err) {
continue
}
return nil, err
}
itemid := fmt.Sprintf("%s-%s-%s", t.Version, t.Release, t.Arch)
if catalog, ok := cloud.Products[id]; ok {
catalog.Items[itemsversion].Items[itemid] = t
} else {
catalog = simplestreams.MetadataCatalog{
Arch: t.Arch,
Version: t.Version,
Items: map[string]*simplestreams.ItemCollection{
itemsversion: {
Items: map[string]interface{}{itemid: t},
},
},
}
cloud.Products[id] = catalog
}
}
if out[stream], err = json.MarshalIndent(&cloud, "", " "); err != nil {
return nil, err
}
}
return out, nil
} | go | func MarshalToolsMetadataProductsJSON(
streamMetadata map[string][]*ToolsMetadata, updated time.Time,
) (out map[string][]byte, err error) {
out = make(map[string][]byte, len(streamMetadata))
for stream, metadata := range streamMetadata {
var cloud simplestreams.CloudMetadata
cloud.Updated = updated.Format(time.RFC1123Z)
cloud.Format = simplestreams.ProductFormat
cloud.ContentId = ToolsContentId(stream)
cloud.Products = make(map[string]simplestreams.MetadataCatalog)
itemsversion := updated.Format("20060102") // YYYYMMDD
for _, t := range metadata {
id, err := t.productId()
if err != nil {
if series.IsUnknownSeriesVersionError(err) {
continue
}
return nil, err
}
itemid := fmt.Sprintf("%s-%s-%s", t.Version, t.Release, t.Arch)
if catalog, ok := cloud.Products[id]; ok {
catalog.Items[itemsversion].Items[itemid] = t
} else {
catalog = simplestreams.MetadataCatalog{
Arch: t.Arch,
Version: t.Version,
Items: map[string]*simplestreams.ItemCollection{
itemsversion: {
Items: map[string]interface{}{itemid: t},
},
},
}
cloud.Products[id] = catalog
}
}
if out[stream], err = json.MarshalIndent(&cloud, "", " "); err != nil {
return nil, err
}
}
return out, nil
} | [
"func",
"MarshalToolsMetadataProductsJSON",
"(",
"streamMetadata",
"map",
"[",
"string",
"]",
"[",
"]",
"*",
"ToolsMetadata",
",",
"updated",
"time",
".",
"Time",
",",
")",
"(",
"out",
"map",
"[",
"string",
"]",
"[",
"]",
"byte",
",",
"err",
"error",
")"... | // MarshalToolsMetadataProductsJSON marshals tools metadata to products JSON.
// updated is the time at which the JSON file was updated. | [
"MarshalToolsMetadataProductsJSON",
"marshals",
"tools",
"metadata",
"to",
"products",
"JSON",
".",
"updated",
"is",
"the",
"time",
"at",
"which",
"the",
"JSON",
"file",
"was",
"updated",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/environs/tools/marshal.go#L93-L134 |
155,573 | juju/juju | cmd/juju/controller/unregister.go | NewUnregisterCommand | func NewUnregisterCommand(store jujuclient.ClientStore) cmd.Command {
if store == nil {
panic("valid store must be specified")
}
cmd := &unregisterCommand{store: store}
return modelcmd.WrapBase(cmd)
} | go | func NewUnregisterCommand(store jujuclient.ClientStore) cmd.Command {
if store == nil {
panic("valid store must be specified")
}
cmd := &unregisterCommand{store: store}
return modelcmd.WrapBase(cmd)
} | [
"func",
"NewUnregisterCommand",
"(",
"store",
"jujuclient",
".",
"ClientStore",
")",
"cmd",
".",
"Command",
"{",
"if",
"store",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"cmd",
":=",
"&",
"unregisterCommand",
"{",
"store",
":",
... | // NewUnregisterCommand returns a command to allow the user to unregister a controller. | [
"NewUnregisterCommand",
"returns",
"a",
"command",
"to",
"allow",
"the",
"user",
"to",
"unregister",
"a",
"controller",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/controller/unregister.go#L19-L25 |
155,574 | juju/juju | cmd/juju/controller/unregister.go | Info | func (c *unregisterCommand) Info() *cmd.Info {
return jujucmd.Info(&cmd.Info{
Name: "unregister",
Args: "<controller name>",
Purpose: "Unregisters a Juju controller.",
Doc: usageUnregisterDetails,
})
} | go | func (c *unregisterCommand) Info() *cmd.Info {
return jujucmd.Info(&cmd.Info{
Name: "unregister",
Args: "<controller name>",
Purpose: "Unregisters a Juju controller.",
Doc: usageUnregisterDetails,
})
} | [
"func",
"(",
"c",
"*",
"unregisterCommand",
")",
"Info",
"(",
")",
"*",
"cmd",
".",
"Info",
"{",
"return",
"jujucmd",
".",
"Info",
"(",
"&",
"cmd",
".",
"Info",
"{",
"Name",
":",
"\"",
"\"",
",",
"Args",
":",
"\"",
"\"",
",",
"Purpose",
":",
"\... | // Info implements Command.Info
// `unregister` may seem generic as a command, but aligns with `register`. | [
"Info",
"implements",
"Command",
".",
"Info",
"unregister",
"may",
"seem",
"generic",
"as",
"a",
"command",
"but",
"aligns",
"with",
"register",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/cmd/juju/controller/unregister.go#L52-L59 |
155,575 | juju/juju | core/presence/presence.go | Disable | func (r *recorder) Disable() {
r.mu.Lock()
defer r.mu.Unlock()
r.enabled = false
r.entries = nil
} | go | func (r *recorder) Disable() {
r.mu.Lock()
defer r.mu.Unlock()
r.enabled = false
r.entries = nil
} | [
"func",
"(",
"r",
"*",
"recorder",
")",
"Disable",
"(",
")",
"{",
"r",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"r",
".",
"enabled",
"=",
"false",
"\n",
"r",
".",
"entries",
"=",
"nil",
... | // Disable implements Recorder. | [
"Disable",
"implements",
"Recorder",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/presence/presence.go#L173-L178 |
155,576 | juju/juju | core/presence/presence.go | Enable | func (r *recorder) Enable() {
r.mu.Lock()
defer r.mu.Unlock()
r.enabled = true
} | go | func (r *recorder) Enable() {
r.mu.Lock()
defer r.mu.Unlock()
r.enabled = true
} | [
"func",
"(",
"r",
"*",
"recorder",
")",
"Enable",
"(",
")",
"{",
"r",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"r",
".",
"enabled",
"=",
"true",
"\n\n",
"}"
] | // Enable implements Recorder. | [
"Enable",
"implements",
"Recorder",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/presence/presence.go#L181-L186 |
155,577 | juju/juju | core/presence/presence.go | IsEnabled | func (r *recorder) IsEnabled() bool {
r.mu.Lock()
defer r.mu.Unlock()
return r.enabled
} | go | func (r *recorder) IsEnabled() bool {
r.mu.Lock()
defer r.mu.Unlock()
return r.enabled
} | [
"func",
"(",
"r",
"*",
"recorder",
")",
"IsEnabled",
"(",
")",
"bool",
"{",
"r",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"r",
".",
"enabled",
"\n",
"}"
] | // IsEnabled implements Recorder. | [
"IsEnabled",
"implements",
"Recorder",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/presence/presence.go#L189-L193 |
155,578 | juju/juju | core/presence/presence.go | Connect | func (r *recorder) Connect(server, model, agent string, id uint64, controllerAgent bool, userData string) {
r.mu.Lock()
defer r.mu.Unlock()
if !r.enabled {
return
}
pos := r.findIndex(server, id)
if pos == -1 {
r.entries = append(r.entries, Value{
Model: model,
Server: server,
Agent: agent,
ControllerAgent: controllerAgent,
ConnectionID: id,
Status: Alive,
UserData: userData,
LastSeen: r.clock.Now(),
})
} else {
// Need to access the value in the array, not a copy of it.
r.entries[pos].Status = Alive
r.entries[pos].LastSeen = r.clock.Now()
}
} | go | func (r *recorder) Connect(server, model, agent string, id uint64, controllerAgent bool, userData string) {
r.mu.Lock()
defer r.mu.Unlock()
if !r.enabled {
return
}
pos := r.findIndex(server, id)
if pos == -1 {
r.entries = append(r.entries, Value{
Model: model,
Server: server,
Agent: agent,
ControllerAgent: controllerAgent,
ConnectionID: id,
Status: Alive,
UserData: userData,
LastSeen: r.clock.Now(),
})
} else {
// Need to access the value in the array, not a copy of it.
r.entries[pos].Status = Alive
r.entries[pos].LastSeen = r.clock.Now()
}
} | [
"func",
"(",
"r",
"*",
"recorder",
")",
"Connect",
"(",
"server",
",",
"model",
",",
"agent",
"string",
",",
"id",
"uint64",
",",
"controllerAgent",
"bool",
",",
"userData",
"string",
")",
"{",
"r",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
... | // Connect implements Recorder. | [
"Connect",
"implements",
"Recorder",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/presence/presence.go#L205-L229 |
155,579 | juju/juju | core/presence/presence.go | Disconnect | func (r *recorder) Disconnect(server string, id uint64) {
r.mu.Lock()
defer r.mu.Unlock()
if !r.enabled {
return
}
if pos := r.findIndex(server, id); pos >= 0 {
if pos == 0 {
r.entries = r.entries[1:]
} else {
r.entries = append(r.entries[0:pos], r.entries[pos+1:]...)
}
}
} | go | func (r *recorder) Disconnect(server string, id uint64) {
r.mu.Lock()
defer r.mu.Unlock()
if !r.enabled {
return
}
if pos := r.findIndex(server, id); pos >= 0 {
if pos == 0 {
r.entries = r.entries[1:]
} else {
r.entries = append(r.entries[0:pos], r.entries[pos+1:]...)
}
}
} | [
"func",
"(",
"r",
"*",
"recorder",
")",
"Disconnect",
"(",
"server",
"string",
",",
"id",
"uint64",
")",
"{",
"r",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"!",
"r",
".",
"enabled",
... | // Disconnect implements Recorder. | [
"Disconnect",
"implements",
"Recorder",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/presence/presence.go#L232-L246 |
155,580 | juju/juju | core/presence/presence.go | Activity | func (r *recorder) Activity(server string, id uint64) {
r.mu.Lock()
defer r.mu.Unlock()
if !r.enabled {
return
}
if pos := r.findIndex(server, id); pos >= 0 {
r.entries[pos].LastSeen = r.clock.Now()
}
} | go | func (r *recorder) Activity(server string, id uint64) {
r.mu.Lock()
defer r.mu.Unlock()
if !r.enabled {
return
}
if pos := r.findIndex(server, id); pos >= 0 {
r.entries[pos].LastSeen = r.clock.Now()
}
} | [
"func",
"(",
"r",
"*",
"recorder",
")",
"Activity",
"(",
"server",
"string",
",",
"id",
"uint64",
")",
"{",
"r",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"!",
"r",
".",
"enabled",
"... | // Activity implements Recorder. | [
"Activity",
"implements",
"Recorder",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/presence/presence.go#L249-L259 |
155,581 | juju/juju | core/presence/presence.go | ServerDown | func (r *recorder) ServerDown(server string) {
r.mu.Lock()
defer r.mu.Unlock()
if !r.enabled {
return
}
for i, value := range r.entries {
if value.Server == server {
r.entries[i].Status = Missing
}
}
} | go | func (r *recorder) ServerDown(server string) {
r.mu.Lock()
defer r.mu.Unlock()
if !r.enabled {
return
}
for i, value := range r.entries {
if value.Server == server {
r.entries[i].Status = Missing
}
}
} | [
"func",
"(",
"r",
"*",
"recorder",
")",
"ServerDown",
"(",
"server",
"string",
")",
"{",
"r",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"!",
"r",
".",
"enabled",
"{",
"return",
"\n",
... | // ServerDown implements Recorder. | [
"ServerDown",
"implements",
"Recorder",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/presence/presence.go#L262-L274 |
155,582 | juju/juju | core/presence/presence.go | UpdateServer | func (r *recorder) UpdateServer(server string, connections []Value) error {
r.mu.Lock()
defer r.mu.Unlock()
if !r.enabled {
return errors.New("recorder not enabled")
}
entries := make([]Value, 0, len(r.entries))
for _, value := range r.entries {
if value.Server != server {
entries = append(entries, value)
}
}
for _, value := range connections {
if value.Server != server {
return errors.Errorf("connection server mismatch, got %q expected %q", value.Server, server)
}
value.Status = Alive
value.LastSeen = r.clock.Now()
entries = append(entries, value)
}
r.entries = entries
return nil
} | go | func (r *recorder) UpdateServer(server string, connections []Value) error {
r.mu.Lock()
defer r.mu.Unlock()
if !r.enabled {
return errors.New("recorder not enabled")
}
entries := make([]Value, 0, len(r.entries))
for _, value := range r.entries {
if value.Server != server {
entries = append(entries, value)
}
}
for _, value := range connections {
if value.Server != server {
return errors.Errorf("connection server mismatch, got %q expected %q", value.Server, server)
}
value.Status = Alive
value.LastSeen = r.clock.Now()
entries = append(entries, value)
}
r.entries = entries
return nil
} | [
"func",
"(",
"r",
"*",
"recorder",
")",
"UpdateServer",
"(",
"server",
"string",
",",
"connections",
"[",
"]",
"Value",
")",
"error",
"{",
"r",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
... | // UpdateServer implements Recorder. | [
"UpdateServer",
"implements",
"Recorder",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/presence/presence.go#L277-L302 |
155,583 | juju/juju | core/presence/presence.go | Connections | func (r *recorder) Connections() Connections {
r.mu.Lock()
defer r.mu.Unlock()
entries := make([]Value, len(r.entries))
copy(entries, r.entries)
return &connections{values: entries}
} | go | func (r *recorder) Connections() Connections {
r.mu.Lock()
defer r.mu.Unlock()
entries := make([]Value, len(r.entries))
copy(entries, r.entries)
return &connections{values: entries}
} | [
"func",
"(",
"r",
"*",
"recorder",
")",
"Connections",
"(",
")",
"Connections",
"{",
"r",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"entries",
":=",
"make",
"(",
"[",
"]",
"Value",
",",
"l... | // Connections implements Recorder. | [
"Connections",
"implements",
"Recorder",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/presence/presence.go#L305-L312 |
155,584 | juju/juju | core/presence/presence.go | ForModel | func (c *connections) ForModel(model string) Connections {
var values []Value
for _, value := range c.values {
if value.Model == model {
values = append(values, value)
}
}
return &connections{model: model, values: values}
} | go | func (c *connections) ForModel(model string) Connections {
var values []Value
for _, value := range c.values {
if value.Model == model {
values = append(values, value)
}
}
return &connections{model: model, values: values}
} | [
"func",
"(",
"c",
"*",
"connections",
")",
"ForModel",
"(",
"model",
"string",
")",
"Connections",
"{",
"var",
"values",
"[",
"]",
"Value",
"\n",
"for",
"_",
",",
"value",
":=",
"range",
"c",
".",
"values",
"{",
"if",
"value",
".",
"Model",
"==",
"... | // ForModel implements Connections. | [
"ForModel",
"implements",
"Connections",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/presence/presence.go#L315-L323 |
155,585 | juju/juju | core/presence/presence.go | ForServer | func (c *connections) ForServer(server string) Connections {
var values []Value
for _, value := range c.values {
if value.Server == server {
values = append(values, value)
}
}
return &connections{model: c.model, values: values}
} | go | func (c *connections) ForServer(server string) Connections {
var values []Value
for _, value := range c.values {
if value.Server == server {
values = append(values, value)
}
}
return &connections{model: c.model, values: values}
} | [
"func",
"(",
"c",
"*",
"connections",
")",
"ForServer",
"(",
"server",
"string",
")",
"Connections",
"{",
"var",
"values",
"[",
"]",
"Value",
"\n",
"for",
"_",
",",
"value",
":=",
"range",
"c",
".",
"values",
"{",
"if",
"value",
".",
"Server",
"==",
... | // ForServer implements Connections. | [
"ForServer",
"implements",
"Connections",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/presence/presence.go#L326-L334 |
155,586 | juju/juju | core/presence/presence.go | ForAgent | func (c *connections) ForAgent(agent string) Connections {
var values []Value
for _, value := range c.values {
if value.Agent == agent {
values = append(values, value)
}
}
return &connections{model: c.model, values: values}
} | go | func (c *connections) ForAgent(agent string) Connections {
var values []Value
for _, value := range c.values {
if value.Agent == agent {
values = append(values, value)
}
}
return &connections{model: c.model, values: values}
} | [
"func",
"(",
"c",
"*",
"connections",
")",
"ForAgent",
"(",
"agent",
"string",
")",
"Connections",
"{",
"var",
"values",
"[",
"]",
"Value",
"\n",
"for",
"_",
",",
"value",
":=",
"range",
"c",
".",
"values",
"{",
"if",
"value",
".",
"Agent",
"==",
"... | // ForAgent implements Connections. | [
"ForAgent",
"implements",
"Connections",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/presence/presence.go#L337-L345 |
155,587 | juju/juju | core/presence/presence.go | Models | func (c *connections) Models() []string {
models := set.NewStrings()
for _, value := range c.values {
models.Add(value.Model)
}
return models.Values()
} | go | func (c *connections) Models() []string {
models := set.NewStrings()
for _, value := range c.values {
models.Add(value.Model)
}
return models.Values()
} | [
"func",
"(",
"c",
"*",
"connections",
")",
"Models",
"(",
")",
"[",
"]",
"string",
"{",
"models",
":=",
"set",
".",
"NewStrings",
"(",
")",
"\n",
"for",
"_",
",",
"value",
":=",
"range",
"c",
".",
"values",
"{",
"models",
".",
"Add",
"(",
"value"... | // Models implements Connections. | [
"Models",
"implements",
"Connections",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/presence/presence.go#L353-L359 |
155,588 | juju/juju | core/presence/presence.go | Servers | func (c *connections) Servers() []string {
servers := set.NewStrings()
for _, value := range c.values {
servers.Add(value.Server)
}
return servers.Values()
} | go | func (c *connections) Servers() []string {
servers := set.NewStrings()
for _, value := range c.values {
servers.Add(value.Server)
}
return servers.Values()
} | [
"func",
"(",
"c",
"*",
"connections",
")",
"Servers",
"(",
")",
"[",
"]",
"string",
"{",
"servers",
":=",
"set",
".",
"NewStrings",
"(",
")",
"\n",
"for",
"_",
",",
"value",
":=",
"range",
"c",
".",
"values",
"{",
"servers",
".",
"Add",
"(",
"val... | // Servers implements Connections. | [
"Servers",
"implements",
"Connections",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/presence/presence.go#L362-L368 |
155,589 | juju/juju | core/presence/presence.go | Agents | func (c *connections) Agents() []string {
agents := set.NewStrings()
for _, value := range c.values {
agents.Add(value.Agent)
}
return agents.Values()
} | go | func (c *connections) Agents() []string {
agents := set.NewStrings()
for _, value := range c.values {
agents.Add(value.Agent)
}
return agents.Values()
} | [
"func",
"(",
"c",
"*",
"connections",
")",
"Agents",
"(",
")",
"[",
"]",
"string",
"{",
"agents",
":=",
"set",
".",
"NewStrings",
"(",
")",
"\n",
"for",
"_",
",",
"value",
":=",
"range",
"c",
".",
"values",
"{",
"agents",
".",
"Add",
"(",
"value"... | // Agents implements Connections. | [
"Agents",
"implements",
"Connections",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/presence/presence.go#L371-L377 |
155,590 | juju/juju | core/presence/presence.go | AgentStatus | func (c *connections) AgentStatus(agent string) (Status, error) {
if c.model == "" {
return Unknown, errors.New("connections not limited to a model, agent ambiguous")
}
result := Unknown
for _, value := range c.values {
if value.Agent == agent && !value.ControllerAgent {
if value.Status > result {
result = value.Status
}
}
}
return result, nil
} | go | func (c *connections) AgentStatus(agent string) (Status, error) {
if c.model == "" {
return Unknown, errors.New("connections not limited to a model, agent ambiguous")
}
result := Unknown
for _, value := range c.values {
if value.Agent == agent && !value.ControllerAgent {
if value.Status > result {
result = value.Status
}
}
}
return result, nil
} | [
"func",
"(",
"c",
"*",
"connections",
")",
"AgentStatus",
"(",
"agent",
"string",
")",
"(",
"Status",
",",
"error",
")",
"{",
"if",
"c",
".",
"model",
"==",
"\"",
"\"",
"{",
"return",
"Unknown",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\... | // AgentStatus implements Connections. | [
"AgentStatus",
"implements",
"Connections",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/core/presence/presence.go#L380-L393 |
155,591 | juju/juju | provider/cloudsigma/environ.go | SetConfig | func (env *environ) SetConfig(cfg *config.Config) error {
env.lock.Lock()
defer env.lock.Unlock()
ecfg, err := validateConfig(cfg, env.ecfg)
if err != nil {
return errors.Trace(err)
}
env.ecfg = ecfg
return nil
} | go | func (env *environ) SetConfig(cfg *config.Config) error {
env.lock.Lock()
defer env.lock.Unlock()
ecfg, err := validateConfig(cfg, env.ecfg)
if err != nil {
return errors.Trace(err)
}
env.ecfg = ecfg
return nil
} | [
"func",
"(",
"env",
"*",
"environ",
")",
"SetConfig",
"(",
"cfg",
"*",
"config",
".",
"Config",
")",
"error",
"{",
"env",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"env",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"ecfg",
",",
"err",
... | // SetConfig updates the Environ's configuration.
//
// Calls to SetConfig do not affect the configuration of values previously obtained
// from Storage. | [
"SetConfig",
"updates",
"the",
"Environ",
"s",
"configuration",
".",
"Calls",
"to",
"SetConfig",
"do",
"not",
"affect",
"the",
"configuration",
"of",
"values",
"previously",
"obtained",
"from",
"Storage",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/cloudsigma/environ.go#L48-L59 |
155,592 | juju/juju | provider/cloudsigma/environ.go | ControllerInstances | func (e *environ) ControllerInstances(ctx context.ProviderCallContext, controllerUUID string) ([]instance.Id, error) {
return e.client.getControllerIds()
} | go | func (e *environ) ControllerInstances(ctx context.ProviderCallContext, controllerUUID string) ([]instance.Id, error) {
return e.client.getControllerIds()
} | [
"func",
"(",
"e",
"*",
"environ",
")",
"ControllerInstances",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
",",
"controllerUUID",
"string",
")",
"(",
"[",
"]",
"instance",
".",
"Id",
",",
"error",
")",
"{",
"return",
"e",
".",
"client",
".",
"getCo... | // ControllerInstances is part of the Environ interface. | [
"ControllerInstances",
"is",
"part",
"of",
"the",
"Environ",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/cloudsigma/environ.go#L98-L100 |
155,593 | juju/juju | provider/cloudsigma/environ.go | Destroy | func (env *environ) Destroy(ctx context.ProviderCallContext) error {
// You can probably ignore this method; the common implementation should work.
return common.Destroy(env, ctx)
} | go | func (env *environ) Destroy(ctx context.ProviderCallContext) error {
// You can probably ignore this method; the common implementation should work.
return common.Destroy(env, ctx)
} | [
"func",
"(",
"env",
"*",
"environ",
")",
"Destroy",
"(",
"ctx",
"context",
".",
"ProviderCallContext",
")",
"error",
"{",
"// You can probably ignore this method; the common implementation should work.",
"return",
"common",
".",
"Destroy",
"(",
"env",
",",
"ctx",
")",... | // Destroy shuts down all known machines and destroys the
// rest of the environment. Note that on some providers,
// very recently started instances may not be destroyed
// because they are not yet visible.
//
// When Destroy has been called, any Environ referring to the
// same remote environment may become invalid | [
"Destroy",
"shuts",
"down",
"all",
"known",
"machines",
"and",
"destroys",
"the",
"rest",
"of",
"the",
"environment",
".",
"Note",
"that",
"on",
"some",
"providers",
"very",
"recently",
"started",
"instances",
"may",
"not",
"be",
"destroyed",
"because",
"they"... | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/cloudsigma/environ.go#L115-L118 |
155,594 | juju/juju | provider/common/instance_configurator.go | NewSshInstanceConfigurator | func NewSshInstanceConfigurator(host string) InstanceConfigurator {
options := ssh.Options{}
options.SetIdentities("/var/lib/juju/system-identity")
// Disable host key checking. We're not sending any sensitive data
// across, and we don't have access to the host's keys from here.
//
// TODO(axw) 2017-12-07 #1732665
// Stop using SSH, instead manage iptables on the machine
// itself. This will also provide firewalling for MAAS and
// LXD machines.
options.SetStrictHostKeyChecking(ssh.StrictHostChecksNo)
options.SetKnownHostsFile(os.DevNull)
return &sshInstanceConfigurator{
client: ssh.DefaultClient,
host: "ubuntu@" + host,
options: &options,
}
} | go | func NewSshInstanceConfigurator(host string) InstanceConfigurator {
options := ssh.Options{}
options.SetIdentities("/var/lib/juju/system-identity")
// Disable host key checking. We're not sending any sensitive data
// across, and we don't have access to the host's keys from here.
//
// TODO(axw) 2017-12-07 #1732665
// Stop using SSH, instead manage iptables on the machine
// itself. This will also provide firewalling for MAAS and
// LXD machines.
options.SetStrictHostKeyChecking(ssh.StrictHostChecksNo)
options.SetKnownHostsFile(os.DevNull)
return &sshInstanceConfigurator{
client: ssh.DefaultClient,
host: "ubuntu@" + host,
options: &options,
}
} | [
"func",
"NewSshInstanceConfigurator",
"(",
"host",
"string",
")",
"InstanceConfigurator",
"{",
"options",
":=",
"ssh",
".",
"Options",
"{",
"}",
"\n",
"options",
".",
"SetIdentities",
"(",
"\"",
"\"",
")",
"\n\n",
"// Disable host key checking. We're not sending any s... | // NewSshInstanceConfigurator creates new sshInstanceConfigurator. | [
"NewSshInstanceConfigurator",
"creates",
"new",
"sshInstanceConfigurator",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/common/instance_configurator.go#L46-L65 |
155,595 | juju/juju | provider/common/instance_configurator.go | DropAllPorts | func (c *sshInstanceConfigurator) DropAllPorts(exceptPorts []int, addr string) error {
cmds := []string{
iptables.DropCommand{DestinationAddress: addr}.Render(),
}
for _, port := range exceptPorts {
cmds = append(cmds, iptables.AcceptInternalCommand{
Protocol: "tcp",
DestinationAddress: addr,
DestinationPort: port,
}.Render())
}
output, err := c.runCommand(strings.Join(cmds, "\n"))
if err != nil {
return errors.Errorf("failed to drop all ports: %s", output)
}
logger.Tracef("drop all ports output: %s", output)
return nil
} | go | func (c *sshInstanceConfigurator) DropAllPorts(exceptPorts []int, addr string) error {
cmds := []string{
iptables.DropCommand{DestinationAddress: addr}.Render(),
}
for _, port := range exceptPorts {
cmds = append(cmds, iptables.AcceptInternalCommand{
Protocol: "tcp",
DestinationAddress: addr,
DestinationPort: port,
}.Render())
}
output, err := c.runCommand(strings.Join(cmds, "\n"))
if err != nil {
return errors.Errorf("failed to drop all ports: %s", output)
}
logger.Tracef("drop all ports output: %s", output)
return nil
} | [
"func",
"(",
"c",
"*",
"sshInstanceConfigurator",
")",
"DropAllPorts",
"(",
"exceptPorts",
"[",
"]",
"int",
",",
"addr",
"string",
")",
"error",
"{",
"cmds",
":=",
"[",
"]",
"string",
"{",
"iptables",
".",
"DropCommand",
"{",
"DestinationAddress",
":",
"ad... | // DropAllPorts implements InstanceConfigurator interface. | [
"DropAllPorts",
"implements",
"InstanceConfigurator",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/common/instance_configurator.go#L78-L96 |
155,596 | juju/juju | provider/common/instance_configurator.go | ConfigureExternalIpAddressCommands | func ConfigureExternalIpAddressCommands(apiPort int) []string {
commands := []string{
`printf 'auto eth1\niface eth1 inet dhcp' | sudo tee -a /etc/network/interfaces.d/eth1.cfg`,
"sudo ifup eth1",
iptables.DropCommand{Interface: "eth1"}.Render(),
}
if apiPort > 0 {
commands = append(commands, iptables.AcceptInternalCommand{
Protocol: "tcp",
DestinationPort: apiPort,
}.Render())
}
return commands
} | go | func ConfigureExternalIpAddressCommands(apiPort int) []string {
commands := []string{
`printf 'auto eth1\niface eth1 inet dhcp' | sudo tee -a /etc/network/interfaces.d/eth1.cfg`,
"sudo ifup eth1",
iptables.DropCommand{Interface: "eth1"}.Render(),
}
if apiPort > 0 {
commands = append(commands, iptables.AcceptInternalCommand{
Protocol: "tcp",
DestinationPort: apiPort,
}.Render())
}
return commands
} | [
"func",
"ConfigureExternalIpAddressCommands",
"(",
"apiPort",
"int",
")",
"[",
"]",
"string",
"{",
"commands",
":=",
"[",
"]",
"string",
"{",
"`printf 'auto eth1\\niface eth1 inet dhcp' | sudo tee -a /etc/network/interfaces.d/eth1.cfg`",
",",
"\"",
"\"",
",",
"iptables",
... | // ConfigureExternalIpAddressCommands returns the commands to run to configure
// the external IP address | [
"ConfigureExternalIpAddressCommands",
"returns",
"the",
"commands",
"to",
"run",
"to",
"configure",
"the",
"external",
"IP",
"address"
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/common/instance_configurator.go#L100-L113 |
155,597 | juju/juju | provider/common/instance_configurator.go | ConfigureExternalIpAddress | func (c *sshInstanceConfigurator) ConfigureExternalIpAddress(apiPort int) error {
cmds := ConfigureExternalIpAddressCommands(apiPort)
output, err := c.runCommand(strings.Join(cmds, "\n"))
if err != nil {
return errors.Errorf("failed to drop all ports: %s", output)
}
if err != nil {
return errors.Errorf("failed to allocate external IP address: %s", output)
}
logger.Tracef("configure external ip address output: %s", output)
return nil
} | go | func (c *sshInstanceConfigurator) ConfigureExternalIpAddress(apiPort int) error {
cmds := ConfigureExternalIpAddressCommands(apiPort)
output, err := c.runCommand(strings.Join(cmds, "\n"))
if err != nil {
return errors.Errorf("failed to drop all ports: %s", output)
}
if err != nil {
return errors.Errorf("failed to allocate external IP address: %s", output)
}
logger.Tracef("configure external ip address output: %s", output)
return nil
} | [
"func",
"(",
"c",
"*",
"sshInstanceConfigurator",
")",
"ConfigureExternalIpAddress",
"(",
"apiPort",
"int",
")",
"error",
"{",
"cmds",
":=",
"ConfigureExternalIpAddressCommands",
"(",
"apiPort",
")",
"\n",
"output",
",",
"err",
":=",
"c",
".",
"runCommand",
"(",... | // ConfigureExternalIpAddress implements InstanceConfigurator interface. | [
"ConfigureExternalIpAddress",
"implements",
"InstanceConfigurator",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/common/instance_configurator.go#L116-L127 |
155,598 | juju/juju | provider/common/instance_configurator.go | ChangeIngressRules | func (c *sshInstanceConfigurator) ChangeIngressRules(ipAddress string, insert bool, rules []network.IngressRule) error {
var cmds []string
for _, rule := range rules {
cmds = append(cmds, iptables.IngressRuleCommand{
Rule: rule,
DestinationAddress: ipAddress,
Delete: !insert,
}.Render())
}
output, err := c.runCommand(strings.Join(cmds, "\n"))
if err != nil {
return errors.Errorf("failed to configure ports on external network: %s", output)
}
logger.Tracef("change ports output: %s", output)
return nil
} | go | func (c *sshInstanceConfigurator) ChangeIngressRules(ipAddress string, insert bool, rules []network.IngressRule) error {
var cmds []string
for _, rule := range rules {
cmds = append(cmds, iptables.IngressRuleCommand{
Rule: rule,
DestinationAddress: ipAddress,
Delete: !insert,
}.Render())
}
output, err := c.runCommand(strings.Join(cmds, "\n"))
if err != nil {
return errors.Errorf("failed to configure ports on external network: %s", output)
}
logger.Tracef("change ports output: %s", output)
return nil
} | [
"func",
"(",
"c",
"*",
"sshInstanceConfigurator",
")",
"ChangeIngressRules",
"(",
"ipAddress",
"string",
",",
"insert",
"bool",
",",
"rules",
"[",
"]",
"network",
".",
"IngressRule",
")",
"error",
"{",
"var",
"cmds",
"[",
"]",
"string",
"\n",
"for",
"_",
... | // ChangeIngressRules implements InstanceConfigurator interface. | [
"ChangeIngressRules",
"implements",
"InstanceConfigurator",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/common/instance_configurator.go#L130-L146 |
155,599 | juju/juju | provider/common/instance_configurator.go | FindIngressRules | func (c *sshInstanceConfigurator) FindIngressRules() ([]network.IngressRule, error) {
output, err := c.runCommand("sudo iptables -L INPUT -n")
if err != nil {
return nil, errors.Errorf("failed to list open ports: %s", output)
}
logger.Tracef("find open ports output: %s", output)
return iptables.ParseIngressRules(strings.NewReader(output))
} | go | func (c *sshInstanceConfigurator) FindIngressRules() ([]network.IngressRule, error) {
output, err := c.runCommand("sudo iptables -L INPUT -n")
if err != nil {
return nil, errors.Errorf("failed to list open ports: %s", output)
}
logger.Tracef("find open ports output: %s", output)
return iptables.ParseIngressRules(strings.NewReader(output))
} | [
"func",
"(",
"c",
"*",
"sshInstanceConfigurator",
")",
"FindIngressRules",
"(",
")",
"(",
"[",
"]",
"network",
".",
"IngressRule",
",",
"error",
")",
"{",
"output",
",",
"err",
":=",
"c",
".",
"runCommand",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!... | // FindIngressRules implements InstanceConfigurator interface. | [
"FindIngressRules",
"implements",
"InstanceConfigurator",
"interface",
"."
] | ba728eedb1e44937c7bdc59f374b06400d0c7133 | https://github.com/juju/juju/blob/ba728eedb1e44937c7bdc59f374b06400d0c7133/provider/common/instance_configurator.go#L149-L156 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.