← Back to branch summary

~juju-qa/ubuntu/xenial/juju/2.0-rc2

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/state/migration_export.go

  • Committer: Nicholas Skaggs
  • Date: 2016-09-30 14:39:30 UTC
  • mfrom: (1.8.1)
  • Revision ID: nicholas.skaggs@canonical.com-20160930143930-vwwhrefh6ftckccy
import upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/state/migration_export.go
39
39
        if err := export.readAllSettings(); err != nil {
40
40
                return nil, errors.Trace(err)
41
41
        }
 
42
        if err := export.readAllStorageConstraints(); err != nil {
 
43
                return nil, errors.Trace(err)
 
44
        }
42
45
        if err := export.readAllAnnotations(); err != nil {
43
46
                return nil, errors.Trace(err)
44
47
        }
114
117
                return nil, errors.Trace(err)
115
118
        }
116
119
 
 
120
        if err := export.cloudimagemetadata(); err != nil {
 
121
                return nil, errors.Trace(err)
 
122
        }
 
123
 
117
124
        if err := export.model.Validate(); err != nil {
118
125
                return nil, errors.Trace(err)
119
126
        }
129
136
        model   description.Model
130
137
        logger  loggo.Logger
131
138
 
132
 
        annotations   map[string]annotatorDoc
133
 
        constraints   map[string]bson.M
134
 
        modelSettings map[string]settingsDoc
135
 
        status        map[string]bson.M
136
 
        statusHistory map[string][]historicalStatusDoc
 
139
        annotations             map[string]annotatorDoc
 
140
        constraints             map[string]bson.M
 
141
        modelSettings           map[string]settingsDoc
 
142
        modelStorageConstraints map[string]storageConstraintsDoc
 
143
        status                  map[string]bson.M
 
144
        statusHistory           map[string][]historicalStatusDoc
137
145
        // Map of application name to units. Populated as part
138
146
        // of the applications export.
139
147
        units map[string][]*Unit
190
198
                        CreatedBy:      user.CreatedBy,
191
199
                        DateCreated:    user.DateCreated,
192
200
                        LastConnection: lastConn,
193
 
                        Access:         user.Access,
 
201
                        Access:         string(user.Access),
194
202
                }
195
203
                e.model.AddUser(arg)
196
204
        }
459
467
                return errors.Trace(err)
460
468
        }
461
469
 
462
 
        storageConstraints, err := e.readAllStorageConstraints()
463
 
        if err != nil {
464
 
                return errors.Trace(err)
465
 
        }
466
 
 
467
470
        meterStatus, err := e.readAllMeterStatus()
468
471
        if err != nil {
469
472
                return errors.Trace(err)
483
486
                applicationUnits := e.units[application.Name()]
484
487
                leader := leaders[application.Name()]
485
488
                if err := e.addApplication(addApplicationContext{
486
 
                        application:        application,
487
 
                        units:              applicationUnits,
488
 
                        storageConstraints: storageConstraints,
489
 
                        meterStatus:        meterStatus,
490
 
                        leader:             leader,
491
 
                        payloads:           payloads,
 
489
                        application: application,
 
490
                        units:       applicationUnits,
 
491
                        meterStatus: meterStatus,
 
492
                        leader:      leader,
 
493
                        payloads:    payloads,
492
494
                }); err != nil {
493
495
                        return errors.Trace(err)
494
496
                }
496
498
        return nil
497
499
}
498
500
 
499
 
func (e *exporter) readAllStorageConstraints() (map[string]map[string]StorageConstraints, error) {
 
501
func (e *exporter) readAllStorageConstraints() error {
500
502
        coll, closer := e.st.getCollection(storageConstraintsC)
501
503
        defer closer()
502
504
 
503
 
        result := make(map[string]map[string]StorageConstraints)
 
505
        storageConstraints := make(map[string]storageConstraintsDoc)
504
506
        var doc storageConstraintsDoc
505
 
        var count int
506
507
        iter := coll.Find(nil).Iter()
507
508
        defer iter.Close()
508
509
        for iter.Next(&doc) {
509
 
                result[e.st.localID(doc.DocID)] = doc.Constraints
510
 
                count++
 
510
                storageConstraints[e.st.localID(doc.DocID)] = doc
511
511
        }
512
512
        if err := iter.Err(); err != nil {
513
 
                return nil, errors.Annotate(err, "failed to read storage constraints")
 
513
                return errors.Annotate(err, "failed to read storage constraints")
514
514
        }
515
 
        e.logger.Debugf("read %d storage constraint documents", count)
516
 
        return result, nil
 
515
        e.logger.Debugf("read %d storage constraint documents", len(storageConstraints))
 
516
        e.modelStorageConstraints = storageConstraints
 
517
        return nil
517
518
}
518
519
 
519
 
func (e *exporter) storageConstraints(constraints map[string]StorageConstraints) map[string]description.StorageConstraintArgs {
 
520
func (e *exporter) storageConstraints(doc storageConstraintsDoc) map[string]description.StorageConstraintArgs {
520
521
        result := make(map[string]description.StorageConstraintArgs)
521
 
        for key, value := range constraints {
 
522
        for key, value := range doc.Constraints {
522
523
                result[key] = description.StorageConstraintArgs{
523
524
                        Pool:  value.Pool,
524
525
                        Size:  value.Size,
554
555
}
555
556
 
556
557
type addApplicationContext struct {
557
 
        application        *Application
558
 
        units              []*Unit
559
 
        storageConstraints map[string]map[string]StorageConstraints
560
 
        meterStatus        map[string]*meterStatusDoc
561
 
        leader             string
562
 
        payloads           map[string][]payload.FullPayloadInfo
 
558
        application *Application
 
559
        units       []*Unit
 
560
        meterStatus map[string]*meterStatusDoc
 
561
        leader      string
 
562
        payloads    map[string][]payload.FullPayloadInfo
563
563
}
564
564
 
565
565
func (e *exporter) addApplication(ctx addApplicationContext) error {
567
567
        appName := application.Name()
568
568
        settingsKey := application.settingsKey()
569
569
        leadershipKey := leadershipSettingsKey(appName)
 
570
        storageConstraintsKey := application.storageConstraintsKey()
570
571
 
571
572
        applicationSettingsDoc, found := e.modelSettings[settingsKey]
572
573
        if !found {
592
593
                LeadershipSettings:   leadershipSettingsDoc.Settings,
593
594
                MetricsCredentials:   application.doc.MetricCredentials,
594
595
        }
595
 
        globalKey := application.globalKey()
596
 
        if constraints, found := ctx.storageConstraints[globalKey]; found {
 
596
        if constraints, found := e.modelStorageConstraints[storageConstraintsKey]; found {
597
597
                args.StorageConstraints = e.storageConstraints(constraints)
598
598
        }
599
599
        exApplication := e.model.AddApplication(args)
600
600
        // Find the current application status.
 
601
        globalKey := application.globalKey()
601
602
        statusArgs, err := e.statusArgs(globalKey)
602
603
        if err != nil {
603
604
                return errors.Annotatef(err, "status for application %s", appName)
860
861
        return nil
861
862
}
862
863
 
 
864
func (e *exporter) cloudimagemetadata() error {
 
865
        cloudimagemetadata, err := e.st.CloudImageMetadataStorage.AllCloudImageMetadata()
 
866
        if err != nil {
 
867
                return errors.Trace(err)
 
868
        }
 
869
        e.logger.Debugf("read %d cloudimagemetadata", len(cloudimagemetadata))
 
870
        for _, metadata := range cloudimagemetadata {
 
871
                e.model.AddCloudImageMetadata(description.CloudImageMetadataArgs{
 
872
                        Stream:          metadata.Stream,
 
873
                        Region:          metadata.Region,
 
874
                        Version:         metadata.Version,
 
875
                        Series:          metadata.Series,
 
876
                        Arch:            metadata.Arch,
 
877
                        VirtType:        metadata.VirtType,
 
878
                        RootStorageType: metadata.RootStorageType,
 
879
                        RootStorageSize: metadata.RootStorageSize,
 
880
                        DateCreated:     metadata.DateCreated,
 
881
                        Source:          metadata.Source,
 
882
                        Priority:        metadata.Priority,
 
883
                        ImageId:         metadata.ImageId,
 
884
                })
 
885
        }
 
886
        return nil
 
887
}
 
888
 
863
889
func (e *exporter) actions() error {
864
890
        actions, err := e.st.AllActions()
865
891
        if err != nil {