← 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/allwatcher_internal_test.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/allwatcher_internal_test.go
100
100
                Id:         "0",
101
101
                InstanceId: "i-machine-0",
102
102
                AgentStatus: multiwatcher.StatusInfo{
103
 
                        Current: status.StatusPending,
 
103
                        Current: status.Pending,
104
104
                        Data:    map[string]interface{}{},
105
105
                },
106
106
                InstanceStatus: multiwatcher.StatusInfo{
107
 
                        Current: status.StatusPending,
 
107
                        Current: status.Pending,
108
108
                        Data:    map[string]interface{}{},
109
109
                },
110
110
                Life:                    multiwatcher.Life("alive"),
135
135
                Config:      charm.Settings{"blog-title": "boring"},
136
136
                Subordinate: false,
137
137
                Status: multiwatcher.StatusInfo{
138
 
                        Current: "unknown",
139
 
                        Message: "Waiting for agent initialization to finish",
 
138
                        Current: "waiting",
 
139
                        Message: "waiting for machine",
140
140
                        Data:    map[string]interface{}{},
141
141
                },
142
142
        })
158
158
                Config:      charm.Settings{},
159
159
                Subordinate: true,
160
160
                Status: multiwatcher.StatusInfo{
161
 
                        Current: "unknown",
162
 
                        Message: "Waiting for agent initialization to finish",
 
161
                        Current: "waiting",
 
162
                        Message: "waiting for machine",
163
163
                        Data:    map[string]interface{}{},
164
164
                },
165
165
        })
195
195
                        Ports:       []multiwatcher.Port{},
196
196
                        Subordinate: false,
197
197
                        WorkloadStatus: multiwatcher.StatusInfo{
198
 
                                Current: "unknown",
199
 
                                Message: "Waiting for agent initialization to finish",
 
198
                                Current: "waiting",
 
199
                                Message: "waiting for machine",
200
200
                                Data:    map[string]interface{}{},
201
201
                        },
202
202
                        AgentStatus: multiwatcher.StatusInfo{
218
218
                c.Assert(err, jc.ErrorIsNil)
219
219
                now := time.Now()
220
220
                sInfo := status.StatusInfo{
221
 
                        Status:  status.StatusError,
 
221
                        Status:  status.Error,
222
222
                        Message: m.Tag().String(),
223
223
                        Since:   &now,
224
224
                }
231
231
                        Id:         fmt.Sprint(i + 1),
232
232
                        InstanceId: "i-" + m.Tag().String(),
233
233
                        AgentStatus: multiwatcher.StatusInfo{
234
 
                                Current: status.StatusError,
 
234
                                Current: status.Error,
235
235
                                Message: m.Tag().String(),
236
236
                                Data:    map[string]interface{}{},
237
237
                        },
238
238
                        InstanceStatus: multiwatcher.StatusInfo{
239
 
                                Current: status.StatusPending,
 
239
                                Current: status.Pending,
240
240
                                Data:    map[string]interface{}{},
241
241
                        },
242
242
                        Life:                    multiwatcher.Life("alive"),
276
276
                        Ports:       []multiwatcher.Port{},
277
277
                        Subordinate: true,
278
278
                        WorkloadStatus: multiwatcher.StatusInfo{
279
 
                                Current: "unknown",
280
 
                                Message: "Waiting for agent initialization to finish",
 
279
                                Current: "waiting",
 
280
                                Message: "waiting for machine",
281
281
                                Data:    map[string]interface{}{},
282
282
                        },
283
283
                        AgentStatus: multiwatcher.StatusInfo{
610
610
                        Ports:          []multiwatcher.Port{{"tcp", 12345}},
611
611
                        PortRanges:     []multiwatcher.PortRange{{12345, 12345, "tcp"}},
612
612
                        WorkloadStatus: multiwatcher.StatusInfo{
613
 
                                Current: "unknown",
614
 
                                Message: "Waiting for agent initialization to finish",
 
613
                                Current: "waiting",
 
614
                                Message: "waiting for machine",
615
615
                                Data:    map[string]interface{}{},
616
616
                        },
617
617
                        AgentStatus: multiwatcher.StatusInfo{
646
646
                        Ports:          []multiwatcher.Port{},
647
647
                        PortRanges:     []multiwatcher.PortRange{},
648
648
                        WorkloadStatus: multiwatcher.StatusInfo{
649
 
                                Current: "unknown",
650
 
                                Message: "Waiting for agent initialization to finish",
 
649
                                Current: "waiting",
 
650
                                Message: "waiting for machine",
651
651
                                Data:    map[string]interface{}{},
652
652
                        },
653
653
                        AgentStatus: multiwatcher.StatusInfo{
731
731
                        ModelUUID: s.state.ModelUUID(),
732
732
                        Id:        "0",
733
733
                        AgentStatus: multiwatcher.StatusInfo{
734
 
                                Current: status.StatusPending,
 
734
                                Current: status.Pending,
735
735
                                Data:    map[string]interface{}{},
736
736
                                Since:   &now,
737
737
                        },
738
738
                        InstanceStatus: multiwatcher.StatusInfo{
739
 
                                Current: status.StatusPending,
 
739
                                Current: status.Pending,
740
740
                                Data:    map[string]interface{}{},
741
741
                                Since:   &now,
742
742
                        },
752
752
                        ModelUUID: s.state.ModelUUID(),
753
753
                        Id:        "1",
754
754
                        AgentStatus: multiwatcher.StatusInfo{
755
 
                                Current: status.StatusPending,
 
755
                                Current: status.Pending,
756
756
                                Data:    map[string]interface{}{},
757
757
                                Since:   &now,
758
758
                        },
759
759
                        InstanceStatus: multiwatcher.StatusInfo{
760
 
                                Current: status.StatusPending,
 
760
                                Current: status.Pending,
761
761
                                Data:    map[string]interface{}{},
762
762
                                Since:   &now,
763
763
                        },
781
781
                        ModelUUID: s.state.ModelUUID(),
782
782
                        Id:        "1",
783
783
                        AgentStatus: multiwatcher.StatusInfo{
784
 
                                Current: status.StatusPending,
 
784
                                Current: status.Pending,
785
785
                                Data:    map[string]interface{}{},
786
786
                                Since:   &now,
787
787
                        },
788
788
                        InstanceStatus: multiwatcher.StatusInfo{
789
 
                                Current: status.StatusPending,
 
789
                                Current: status.Pending,
790
790
                                Data:    map[string]interface{}{},
791
791
                                Since:   &now,
792
792
                        },
809
809
                        ModelUUID: s.state.ModelUUID(),
810
810
                        Id:        "1",
811
811
                        AgentStatus: multiwatcher.StatusInfo{
812
 
                                Current: status.StatusPending,
 
812
                                Current: status.Pending,
813
813
                                Data:    map[string]interface{}{},
814
814
                                Since:   &now,
815
815
                        },
816
816
                        InstanceStatus: multiwatcher.StatusInfo{
817
 
                                Current: status.StatusPending,
 
817
                                Current: status.Pending,
818
818
                                Data:    map[string]interface{}{},
819
819
                                Since:   &now,
820
820
                        },
861
861
                        Id:         "0",
862
862
                        InstanceId: "i-0",
863
863
                        AgentStatus: multiwatcher.StatusInfo{
864
 
                                Current: status.StatusPending,
 
864
                                Current: status.Pending,
865
865
                                Data:    map[string]interface{}{},
866
866
                                Since:   &now,
867
867
                        },
868
868
                        InstanceStatus: multiwatcher.StatusInfo{
869
 
                                Current: status.StatusPending,
 
869
                                Current: status.Pending,
870
870
                                Data:    map[string]interface{}{},
871
871
                                Since:   &now,
872
872
                        },
889
889
                        ModelUUID: s.state.ModelUUID(),
890
890
                        Id:        "2",
891
891
                        AgentStatus: multiwatcher.StatusInfo{
892
 
                                Current: status.StatusPending,
 
892
                                Current: status.Pending,
893
893
                                Data:    map[string]interface{}{},
894
894
                                Since:   &now,
895
895
                        },
896
896
                        InstanceStatus: multiwatcher.StatusInfo{
897
 
                                Current: status.StatusPending,
 
897
                                Current: status.Pending,
898
898
                                Data:    map[string]interface{}{},
899
899
                                Since:   &now,
900
900
                        },
913
913
                        Life:      "alive",
914
914
                        Config:    make(map[string]interface{}),
915
915
                        Status: multiwatcher.StatusInfo{
916
 
                                Current: "unknown",
917
 
                                Message: "Waiting for agent initialization to finish",
 
916
                                Current: "waiting",
 
917
                                Message: "waiting for machine",
918
918
                                Data:    map[string]interface{}{},
919
919
                        },
920
920
                },
926
926
                        Series:      "quantal",
927
927
                        MachineId:   "2",
928
928
                        WorkloadStatus: multiwatcher.StatusInfo{
929
 
                                Current: "unknown",
930
 
                                Message: "Waiting for agent initialization to finish",
 
929
                                Current: "waiting",
 
930
                                Message: "waiting for machine",
931
931
                                Data:    map[string]interface{}{},
932
932
                        },
933
933
                        AgentStatus: multiwatcher.StatusInfo{
1022
1022
 
1023
1023
                                now := time.Now()
1024
1024
                                sInfo := status.StatusInfo{
1025
 
                                        Status:  status.StatusError,
 
1025
                                        Status:  status.Error,
1026
1026
                                        Message: "pete tong",
1027
1027
                                        Since:   &now,
1028
1028
                                }
1279
1279
                                initialContents: []multiwatcher.EntityInfo{&multiwatcher.ApplicationInfo{
1280
1280
                                        ModelUUID:   st.ModelUUID(),
1281
1281
                                        Name:        "wordpress",
1282
 
                                        Constraints: constraints.MustParse("mem=99M cpu-cores=2 cpu-power=4"),
 
1282
                                        Constraints: constraints.MustParse("mem=99M cores=2 cpu-power=4"),
1283
1283
                                }},
1284
1284
                                change: watcher.Change{
1285
1285
                                        C:  "constraints",
1410
1410
                        ModelUUID: st0.ModelUUID(),
1411
1411
                        Id:        "0",
1412
1412
                        AgentStatus: multiwatcher.StatusInfo{
1413
 
                                Current: status.StatusPending,
 
1413
                                Current: status.Pending,
1414
1414
                                Data:    map[string]interface{}{},
1415
1415
                        },
1416
1416
                        InstanceStatus: multiwatcher.StatusInfo{
1417
 
                                Current: status.StatusPending,
 
1417
                                Current: status.Pending,
1418
1418
                                Data:    map[string]interface{}{},
1419
1419
                        },
1420
1420
                        Life:      multiwatcher.Life("alive"),
1429
1429
                        ModelUUID: st1.ModelUUID(),
1430
1430
                        Id:        "0",
1431
1431
                        AgentStatus: multiwatcher.StatusInfo{
1432
 
                                Current: status.StatusPending,
 
1432
                                Current: status.Pending,
1433
1433
                                Data:    map[string]interface{}{},
1434
1434
                        },
1435
1435
                        InstanceStatus: multiwatcher.StatusInfo{
1436
 
                                Current: status.StatusPending,
 
1436
                                Current: status.Pending,
1437
1437
                                Data:    map[string]interface{}{},
1438
1438
                        },
1439
1439
                        Life:      multiwatcher.Life("alive"),
1456
1456
                        ModelUUID: st1.ModelUUID(),
1457
1457
                        Id:        "0",
1458
1458
                        AgentStatus: multiwatcher.StatusInfo{
1459
 
                                Current: status.StatusPending,
 
1459
                                Current: status.Pending,
1460
1460
                                Data:    map[string]interface{}{},
1461
1461
                        },
1462
1462
                        InstanceStatus: multiwatcher.StatusInfo{
1463
 
                                Current: status.StatusPending,
 
1463
                                Current: status.Pending,
1464
1464
                                Data:    map[string]interface{}{},
1465
1465
                        },
1466
1466
                        Life:      multiwatcher.Life("dying"),
1482
1482
                        ModelUUID: st1.ModelUUID(),
1483
1483
                        Id:        "0",
1484
1484
                        AgentStatus: multiwatcher.StatusInfo{
1485
 
                                Current: status.StatusPending,
 
1485
                                Current: status.Pending,
1486
1486
                                Data:    map[string]interface{}{},
1487
1487
                        },
1488
1488
                        InstanceStatus: multiwatcher.StatusInfo{
1489
 
                                Current: status.StatusPending,
 
1489
                                Current: status.Pending,
1490
1490
                                Data:    map[string]interface{}{},
1491
1491
                        },
1492
1492
                        Life:      multiwatcher.Life("dead"),
1534
1534
                        Id:         "0",
1535
1535
                        InstanceId: "i-0",
1536
1536
                        AgentStatus: multiwatcher.StatusInfo{
1537
 
                                Current: status.StatusPending,
 
1537
                                Current: status.Pending,
1538
1538
                                Data:    map[string]interface{}{},
1539
1539
                        },
1540
1540
                        InstanceStatus: multiwatcher.StatusInfo{
1541
 
                                Current: status.StatusPending,
 
1541
                                Current: status.Pending,
1542
1542
                                Data:    map[string]interface{}{},
1543
1543
                        },
1544
1544
                        Life:                    multiwatcher.Life("alive"),
1560
1560
                        ModelUUID: st1.ModelUUID(),
1561
1561
                        Id:        "1",
1562
1562
                        AgentStatus: multiwatcher.StatusInfo{
1563
 
                                Current: status.StatusPending,
 
1563
                                Current: status.Pending,
1564
1564
                                Data:    map[string]interface{}{},
1565
1565
                        },
1566
1566
                        InstanceStatus: multiwatcher.StatusInfo{
1567
 
                                Current: status.StatusPending,
 
1567
                                Current: status.Pending,
1568
1568
                                Data:    map[string]interface{}{},
1569
1569
                        },
1570
1570
                        Life:      multiwatcher.Life("alive"),
1582
1582
                        Life:      "alive",
1583
1583
                        Config:    make(map[string]interface{}),
1584
1584
                        Status: multiwatcher.StatusInfo{
1585
 
                                Current: "unknown",
1586
 
                                Message: "Waiting for agent initialization to finish",
 
1585
                                Current: "waiting",
 
1586
                                Message: "waiting for machine",
1587
1587
                                Data:    map[string]interface{}{},
1588
1588
                        },
1589
1589
                },
1595
1595
                        Series:      "quantal",
1596
1596
                        MachineId:   "1",
1597
1597
                        WorkloadStatus: multiwatcher.StatusInfo{
1598
 
                                Current: "unknown",
1599
 
                                Message: "Waiting for agent initialization to finish",
 
1598
                                Current: "waiting",
 
1599
                                Message: "waiting for machine",
1600
1600
                                Data:    map[string]interface{}{},
1601
1601
                        },
1602
1602
                        AgentStatus: multiwatcher.StatusInfo{
1618
1618
                        ModelUUID: st2.ModelUUID(),
1619
1619
                        Id:        "0",
1620
1620
                        AgentStatus: multiwatcher.StatusInfo{
1621
 
                                Current: status.StatusPending,
 
1621
                                Current: status.Pending,
1622
1622
                                Data:    map[string]interface{}{},
1623
1623
                        },
1624
1624
                        InstanceStatus: multiwatcher.StatusInfo{
1625
 
                                Current: status.StatusPending,
 
1625
                                Current: status.Pending,
1626
1626
                                Data:    map[string]interface{}{},
1627
1627
                        },
1628
1628
                        Life:      multiwatcher.Life("alive"),
1770
1770
                        c.Assert(err, jc.ErrorIsNil)
1771
1771
                        now := time.Now()
1772
1772
                        sInfo := status.StatusInfo{
1773
 
                                Status:  status.StatusError,
 
1773
                                Status:  status.Error,
1774
1774
                                Message: "failure",
1775
1775
                                Since:   &now,
1776
1776
                        }
1788
1788
                                                ModelUUID: st.ModelUUID(),
1789
1789
                                                Id:        "0",
1790
1790
                                                AgentStatus: multiwatcher.StatusInfo{
1791
 
                                                        Current: status.StatusError,
 
1791
                                                        Current: status.Error,
1792
1792
                                                        Message: "failure",
1793
1793
                                                        Data:    map[string]interface{}{},
1794
1794
                                                },
1795
1795
                                                InstanceStatus: multiwatcher.StatusInfo{
1796
 
                                                        Current: status.StatusPending,
 
1796
                                                        Current: status.Pending,
1797
1797
                                                        Data:    map[string]interface{}{},
1798
1798
                                                },
1799
1799
                                                Life:      multiwatcher.Life("alive"),
1819
1819
                                                ModelUUID: st.ModelUUID(),
1820
1820
                                                Id:        "0",
1821
1821
                                                AgentStatus: multiwatcher.StatusInfo{
1822
 
                                                        Current: status.StatusError,
 
1822
                                                        Current: status.Error,
1823
1823
                                                        Message: "another failure",
1824
1824
                                                        Data:    map[string]interface{}{},
1825
1825
                                                        Since:   &now,
1826
1826
                                                },
1827
1827
                                                InstanceStatus: multiwatcher.StatusInfo{
1828
 
                                                        Current: status.StatusPending,
 
1828
                                                        Current: status.Pending,
1829
1829
                                                        Data:    map[string]interface{}{},
1830
1830
                                                        Since:   &now,
1831
1831
                                                },
1841
1841
                                                Id:         "0",
1842
1842
                                                InstanceId: "i-0",
1843
1843
                                                AgentStatus: multiwatcher.StatusInfo{
1844
 
                                                        Current: status.StatusError,
 
1844
                                                        Current: status.Error,
1845
1845
                                                        Message: "another failure",
1846
1846
                                                        Data:    map[string]interface{}{},
1847
1847
                                                },
1848
1848
                                                InstanceStatus: multiwatcher.StatusInfo{
1849
 
                                                        Current: status.StatusPending,
 
1849
                                                        Current: status.Pending,
1850
1850
                                                        Data:    map[string]interface{}{},
1851
1851
                                                },
1852
1852
                                                Life:                     multiwatcher.Life("alive"),
1865
1865
                                        ModelUUID: st.ModelUUID(),
1866
1866
                                        Id:        "0",
1867
1867
                                        AgentStatus: multiwatcher.StatusInfo{
1868
 
                                                Current: status.StatusError,
 
1868
                                                Current: status.Error,
1869
1869
                                                Message: "failure",
1870
1870
                                                Data:    map[string]interface{}{},
1871
1871
                                                Since:   &now,
1880
1880
                                                ModelUUID: st.ModelUUID(),
1881
1881
                                                Id:        "0",
1882
1882
                                                AgentStatus: multiwatcher.StatusInfo{
1883
 
                                                        Current: status.StatusError,
 
1883
                                                        Current: status.Error,
1884
1884
                                                        Message: "failure",
1885
1885
                                                        Data:    map[string]interface{}{},
1886
1886
                                                },
1891
1891
                        c.Assert(err, jc.ErrorIsNil)
1892
1892
                        now := time.Now()
1893
1893
                        sInfo := status.StatusInfo{
1894
 
                                Status:  status.StatusStarted,
 
1894
                                Status:  status.Started,
1895
1895
                                Message: "",
1896
1896
                                Since:   &now,
1897
1897
                        }
1904
1904
                                        ModelUUID: st.ModelUUID(),
1905
1905
                                        Id:        "0",
1906
1906
                                        AgentStatus: multiwatcher.StatusInfo{
1907
 
                                                Current: status.StatusError,
 
1907
                                                Current: status.Error,
1908
1908
                                                Message: "failure",
1909
1909
                                                Data:    map[string]interface{}{},
1910
1910
                                                Since:   &now,
1919
1919
                                                ModelUUID: st.ModelUUID(),
1920
1920
                                                Id:        "0",
1921
1921
                                                AgentStatus: multiwatcher.StatusInfo{
1922
 
                                                        Current: status.StatusStarted,
 
1922
                                                        Current: status.Started,
1923
1923
                                                        Data:    make(map[string]interface{}),
1924
1924
                                                },
1925
1925
                                        }}}
2026
2026
                                                MinUnits:  42,
2027
2027
                                                Config:    charm.Settings{},
2028
2028
                                                Status: multiwatcher.StatusInfo{
2029
 
                                                        Current: "unknown",
2030
 
                                                        Message: "Waiting for agent initialization to finish",
 
2029
                                                        Current: "waiting",
 
2030
                                                        Message: "waiting for machine",
2031
2031
                                                        Data:    map[string]interface{}{},
2032
2032
                                                },
2033
2033
                                        }}}
2275
2275
                                initialContents: []multiwatcher.EntityInfo{&multiwatcher.ApplicationInfo{
2276
2276
                                        ModelUUID:   st.ModelUUID(),
2277
2277
                                        Name:        "wordpress",
2278
 
                                        Constraints: constraints.MustParse("mem=99M cpu-cores=2 cpu-power=4"),
 
2278
                                        Constraints: constraints.MustParse("mem=99M cores=2 cpu-power=4"),
2279
2279
                                }},
2280
2280
                                change: watcher.Change{
2281
2281
                                        C:  "constraints",
2333
2333
                        c.Assert(err, jc.ErrorIsNil)
2334
2334
                        now := time.Now()
2335
2335
                        sInfo := status.StatusInfo{
2336
 
                                Status:  status.StatusError,
 
2336
                                Status:  status.Error,
2337
2337
                                Message: "failure",
2338
2338
                                Since:   &now,
2339
2339
                        }
2505
2505
                                                Series:      "quantal",
2506
2506
                                                MachineId:   "0",
2507
2507
                                                WorkloadStatus: multiwatcher.StatusInfo{
2508
 
                                                        Current: "unknown",
2509
 
                                                        Message: "Waiting for agent initialization to finish",
 
2508
                                                        Current: "waiting",
 
2509
                                                        Message: "waiting for machine",
2510
2510
                                                        Data:    map[string]interface{}{},
2511
2511
                                                },
2512
2512
                                                AgentStatus: multiwatcher.StatusInfo{
2538
2538
                        c.Assert(err, jc.ErrorIsNil)
2539
2539
                        now := time.Now()
2540
2540
                        sInfo := status.StatusInfo{
2541
 
                                Status:  status.StatusError,
 
2541
                                Status:  status.Error,
2542
2542
                                Message: "failure",
2543
2543
                                Since:   &now,
2544
2544
                        }
2629
2629
                        c.Assert(err, jc.ErrorIsNil)
2630
2630
                        now := time.Now()
2631
2631
                        sInfo := status.StatusInfo{
2632
 
                                Status:  status.StatusIdle,
 
2632
                                Status:  status.Idle,
2633
2633
                                Message: "",
2634
2634
                                Since:   &now,
2635
2635
                        }
2682
2682
                        c.Assert(err, jc.ErrorIsNil)
2683
2683
                        now := time.Now()
2684
2684
                        sInfo := status.StatusInfo{
2685
 
                                Status:  status.StatusIdle,
 
2685
                                Status:  status.Idle,
2686
2686
                                Message: "",
2687
2687
                                Since:   &now,
2688
2688
                        }
2689
2689
                        err = u.SetAgentStatus(sInfo)
2690
2690
                        c.Assert(err, jc.ErrorIsNil)
2691
2691
                        sInfo = status.StatusInfo{
2692
 
                                Status:  status.StatusMaintenance,
 
2692
                                Status:  status.Maintenance,
2693
2693
                                Message: "doing work",
2694
2694
                                Since:   &now,
2695
2695
                        }
2742
2742
                        c.Assert(err, jc.ErrorIsNil)
2743
2743
                        now := time.Now()
2744
2744
                        sInfo := status.StatusInfo{
2745
 
                                Status:  status.StatusError,
 
2745
                                Status:  status.Error,
2746
2746
                                Message: "hook error",
2747
2747
                                Data: map[string]interface{}{
2748
2748
                                        "1st-key": "one",
2802
2802
                        c.Assert(err, jc.ErrorIsNil)
2803
2803
                        now := time.Now()
2804
2804
                        sInfo := status.StatusInfo{
2805
 
                                Status:  status.StatusActive,
 
2805
                                Status:  status.Active,
2806
2806
                                Message: "",
2807
2807
                                Since:   &now,
2808
2808
                        }
2937
2937
                                                Ports:       []multiwatcher.Port{},
2938
2938
                                                PortRanges:  []multiwatcher.PortRange{},
2939
2939
                                                WorkloadStatus: multiwatcher.StatusInfo{
2940
 
                                                        Current: "unknown",
2941
 
                                                        Message: "Waiting for agent initialization to finish",
 
2940
                                                        Current: "waiting",
 
2941
                                                        Message: "waiting for machine",
2942
2942
                                                        Data:    map[string]interface{}{},
2943
2943
                                                },
2944
2944
                                                AgentStatus: multiwatcher.StatusInfo{
2969
2969
                                                Ports:          []multiwatcher.Port{{"tcp", 12345}},
2970
2970
                                                PortRanges:     []multiwatcher.PortRange{{12345, 12345, "tcp"}},
2971
2971
                                                WorkloadStatus: multiwatcher.StatusInfo{
2972
 
                                                        Current: "unknown",
2973
 
                                                        Message: "Waiting for agent initialization to finish",
 
2972
                                                        Current: "waiting",
 
2973
                                                        Message: "waiting for machine",
2974
2974
                                                        Data:    map[string]interface{}{},
2975
2975
                                                },
2976
2976
                                                AgentStatus: multiwatcher.StatusInfo{
3001
3001
                                                Ports:          []multiwatcher.Port{},
3002
3002
                                                PortRanges:     []multiwatcher.PortRange{},
3003
3003
                                                WorkloadStatus: multiwatcher.StatusInfo{
3004
 
                                                        Current: "unknown",
3005
 
                                                        Message: "Waiting for agent initialization to finish",
 
3004
                                                        Current: "waiting",
 
3005
                                                        Message: "waiting for machine",
3006
3006
                                                        Data:    map[string]interface{}{},
3007
3007
                                                },
3008
3008
                                                AgentStatus: multiwatcher.StatusInfo{
3030
3030
                                                Ports:       []multiwatcher.Port{},
3031
3031
                                                PortRanges:  []multiwatcher.PortRange{},
3032
3032
                                                WorkloadStatus: multiwatcher.StatusInfo{
3033
 
                                                        Current: "unknown",
3034
 
                                                        Message: "Waiting for agent initialization to finish",
 
3033
                                                        Current: "waiting",
 
3034
                                                        Message: "waiting for machine",
3035
3035
                                                        Data:    map[string]interface{}{},
3036
3036
                                                },
3037
3037
                                                AgentStatus: multiwatcher.StatusInfo{