+ {{/job-page/parts/body}}
+ `);
+
+ return wait().then(() => {
+ assert.ok(
+ find('[data-test-page-content] .section > .inner-content'),
+ 'Content is rendered in a section in a gutter menu'
+ );
+ assert.ok(
+ find('[data-test-subnav="job"] + .section > .inner-content'),
+ 'Content is rendered immediately after the subnav'
+ );
+ });
+});
+
+test('onNamespaceChange action is called when the namespace changes in the nested gutter menu', function(assert) {
+ const namespaceSpy = sinon.spy();
+
+ this.set('job', {});
+ this.set('onNamespaceChange', namespaceSpy);
+
+ this.render(hbs`
+ {{#job-page/parts/body job=job onNamespaceChange=onNamespaceChange}}
+
Inner content
+ {{/job-page/parts/body}}
+ `);
+
+ return wait().then(() => {
+ clickTrigger('[data-test-namespace-switcher]');
+ click(findAll('.ember-power-select-option')[1]);
+
+ return wait().then(() => {
+ assert.ok(namespaceSpy.calledOnce, 'Switching namespaces calls the onNamespaceChange action');
+ });
+ });
+});
diff --git a/ui/tests/integration/job-page/parts/children-test.js b/ui/tests/integration/job-page/parts/children-test.js
new file mode 100644
index 000000000..9b7149d41
--- /dev/null
+++ b/ui/tests/integration/job-page/parts/children-test.js
@@ -0,0 +1,206 @@
+import { getOwner } from '@ember/application';
+import { assign } from '@ember/polyfills';
+import { run } from '@ember/runloop';
+import hbs from 'htmlbars-inline-precompile';
+import wait from 'ember-test-helpers/wait';
+import { findAll, find, click } from 'ember-native-dom-helpers';
+import sinon from 'sinon';
+import { test, moduleForComponent } from 'ember-qunit';
+import { startMirage } from 'nomad-ui/initializers/ember-cli-mirage';
+
+moduleForComponent('job-page/parts/children', 'Integration | Component | job-page/parts/children', {
+ integration: true,
+ beforeEach() {
+ window.localStorage.clear();
+ this.store = getOwner(this).lookup('service:store');
+ this.server = startMirage();
+ this.server.create('namespace');
+ },
+ afterEach() {
+ this.server.shutdown();
+ window.localStorage.clear();
+ },
+});
+
+const props = (job, options = {}) =>
+ assign(
+ {
+ job,
+ sortProperty: 'name',
+ sortDescending: true,
+ currentPage: 1,
+ gotoJob: () => {},
+ },
+ options
+ );
+
+test('lists each child', function(assert) {
+ let parent;
+
+ this.server.create('job', 'periodic', {
+ id: 'parent',
+ childrenCount: 3,
+ createAllocations: false,
+ });
+
+ this.store.findAll('job');
+
+ return wait().then(() => {
+ run(() => {
+ parent = this.store.peekAll('job').findBy('plainId', 'parent');
+ });
+
+ this.setProperties(props(parent));
+
+ this.render(hbs`
+ {{job-page/parts/children
+ job=job
+ sortProperty=sortProperty
+ sortDescending=sortDescending
+ currentPage=currentPage
+ gotoJob=gotoJob}}
+ `);
+
+ return wait().then(() => {
+ assert.equal(
+ findAll('[data-test-job-name]').length,
+ parent.get('children.length'),
+ 'A row for each child'
+ );
+ });
+ });
+});
+
+test('eventually paginates', function(assert) {
+ let parent;
+
+ this.server.create('job', 'periodic', {
+ id: 'parent',
+ childrenCount: 11,
+ createAllocations: false,
+ });
+
+ this.store.findAll('job');
+
+ return wait().then(() => {
+ run(() => {
+ parent = this.store.peekAll('job').findBy('plainId', 'parent');
+ });
+
+ this.setProperties(props(parent));
+
+ this.render(hbs`
+ {{job-page/parts/children
+ job=job
+ sortProperty=sortProperty
+ sortDescending=sortDescending
+ currentPage=currentPage
+ gotoJob=gotoJob}}
+ `);
+
+ return wait().then(() => {
+ const childrenCount = parent.get('children.length');
+ assert.ok(childrenCount > 10, 'Parent has more children than one page size');
+ assert.equal(findAll('[data-test-job-name]').length, 10, 'Table length maxes out at 10');
+ assert.ok(find('.pagination-next'), 'Next button is rendered');
+
+ assert.ok(
+ new RegExp(`1.10.+?${childrenCount}`).test(find('.pagination-numbers').textContent.trim())
+ );
+ });
+ });
+});
+
+test('is sorted based on the sortProperty and sortDescending properties', function(assert) {
+ let parent;
+
+ this.server.create('job', 'periodic', {
+ id: 'parent',
+ childrenCount: 3,
+ createAllocations: false,
+ });
+
+ this.store.findAll('job');
+
+ return wait().then(() => {
+ run(() => {
+ parent = this.store.peekAll('job').findBy('plainId', 'parent');
+ });
+
+ this.setProperties(props(parent));
+
+ this.render(hbs`
+ {{job-page/parts/children
+ job=job
+ sortProperty=sortProperty
+ sortDescending=sortDescending
+ currentPage=currentPage
+ gotoJob=gotoJob}}
+ `);
+
+ return wait().then(() => {
+ const sortedChildren = parent.get('children').sortBy('name');
+ const childRows = findAll('[data-test-job-name]');
+
+ sortedChildren.reverse().forEach((child, index) => {
+ assert.equal(
+ childRows[index].textContent.trim(),
+ child.get('name'),
+ `Child ${index} is ${child.get('name')}`
+ );
+ });
+
+ this.set('sortDescending', false);
+
+ sortedChildren.forEach((child, index) => {
+ assert.equal(
+ childRows[index].textContent.trim(),
+ child.get('name'),
+ `Child ${index} is ${child.get('name')}`
+ );
+ });
+ });
+ });
+});
+
+test('gotoJob is called when a job row is clicked', function(assert) {
+ let parent;
+ const gotoJobSpy = sinon.spy();
+
+ this.server.create('job', 'periodic', {
+ id: 'parent',
+ childrenCount: 1,
+ createAllocations: false,
+ });
+
+ this.store.findAll('job');
+
+ return wait().then(() => {
+ run(() => {
+ parent = this.store.peekAll('job').findBy('plainId', 'parent');
+ });
+
+ this.setProperties(
+ props(parent, {
+ gotoJob: gotoJobSpy,
+ })
+ );
+
+ this.render(hbs`
+ {{job-page/parts/children
+ job=job
+ sortProperty=sortProperty
+ sortDescending=sortDescending
+ currentPage=currentPage
+ gotoJob=gotoJob}}
+ `);
+
+ return wait().then(() => {
+ click('tr.job-row');
+ assert.ok(
+ gotoJobSpy.withArgs(parent.get('children.firstObject')).calledOnce,
+ 'Clicking the job row calls the gotoJob action'
+ );
+ });
+ });
+});
diff --git a/ui/tests/integration/job-page/parts/evaluations-test.js b/ui/tests/integration/job-page/parts/evaluations-test.js
new file mode 100644
index 000000000..982c1d294
--- /dev/null
+++ b/ui/tests/integration/job-page/parts/evaluations-test.js
@@ -0,0 +1,65 @@
+import { run } from '@ember/runloop';
+import { getOwner } from '@ember/application';
+import { test, moduleForComponent } from 'ember-qunit';
+import { findAll } from 'ember-native-dom-helpers';
+import wait from 'ember-test-helpers/wait';
+import hbs from 'htmlbars-inline-precompile';
+import { startMirage } from 'nomad-ui/initializers/ember-cli-mirage';
+
+moduleForComponent(
+ 'job-page/parts/evaluations',
+ 'Integration | Component | job-page/parts/evaluations',
+ {
+ integration: true,
+ beforeEach() {
+ window.localStorage.clear();
+ this.store = getOwner(this).lookup('service:store');
+ this.server = startMirage();
+ this.server.create('namespace');
+ },
+ afterEach() {
+ this.server.shutdown();
+ window.localStorage.clear();
+ },
+ }
+);
+
+test('lists all evaluations for the job', function(assert) {
+ let job;
+
+ this.server.create('job', { noFailedPlacements: true, createAllocations: false });
+ this.store.findAll('job');
+
+ return wait().then(() => {
+ run(() => {
+ job = this.store.peekAll('job').get('firstObject');
+ });
+
+ this.setProperties({ job });
+
+ this.render(hbs`
+ {{job-page/parts/evaluations job=job}}
+ `);
+
+ return wait().then(() => {
+ const evaluationRows = findAll('[data-test-evaluation]');
+ assert.equal(
+ evaluationRows.length,
+ job.get('evaluations.length'),
+ 'All evaluations are listed'
+ );
+
+ job
+ .get('evaluations')
+ .sortBy('modifyIndex')
+ .reverse()
+ .forEach((evaluation, index) => {
+ assert.equal(
+ evaluationRows[index].querySelector('[data-test-id]').textContent.trim(),
+ evaluation.get('shortId'),
+ `Evaluation ${index} is ${evaluation.get('shortId')}`
+ );
+ });
+ });
+ });
+});
diff --git a/ui/tests/integration/job-page/parts/placement-failures-test.js b/ui/tests/integration/job-page/parts/placement-failures-test.js
new file mode 100644
index 000000000..844e51c5b
--- /dev/null
+++ b/ui/tests/integration/job-page/parts/placement-failures-test.js
@@ -0,0 +1,90 @@
+import { getOwner } from '@ember/application';
+import { run } from '@ember/runloop';
+import hbs from 'htmlbars-inline-precompile';
+import wait from 'ember-test-helpers/wait';
+import { findAll, find } from 'ember-native-dom-helpers';
+import { test, moduleForComponent } from 'ember-qunit';
+import { startMirage } from 'nomad-ui/initializers/ember-cli-mirage';
+import { initialize as fragmentSerializerInitializer } from 'nomad-ui/initializers/fragment-serializer';
+
+moduleForComponent(
+ 'job-page/parts/placement-failures',
+ 'Integration | Component | job-page/parts/placement-failures',
+ {
+ integration: true,
+ beforeEach() {
+ fragmentSerializerInitializer(getOwner(this));
+ window.localStorage.clear();
+ this.store = getOwner(this).lookup('service:store');
+ this.server = startMirage();
+ this.server.create('namespace');
+ },
+ afterEach() {
+ this.server.shutdown();
+ window.localStorage.clear();
+ },
+ }
+);
+
+test('when the job has placement failures, they are called out', function(assert) {
+ this.server.create('job', { failedPlacements: true, createAllocations: false });
+ this.store.findAll('job').then(jobs => {
+ jobs.forEach(job => job.reload());
+ });
+
+ return wait().then(() => {
+ run(() => {
+ this.set('job', this.store.peekAll('job').get('firstObject'));
+ });
+
+ this.render(hbs`
+ {{job-page/parts/placement-failures job=job}})
+ `);
+
+ return wait().then(() => {
+ const failedEvaluation = this.get('job.evaluations')
+ .filterBy('hasPlacementFailures')
+ .sortBy('modifyIndex')
+ .reverse()
+ .get('firstObject');
+ const failedTGAllocs = failedEvaluation.get('failedTGAllocs');
+
+ assert.ok(find('[data-test-placement-failures]'), 'Placement failures section found');
+
+ const taskGroupLabels = findAll('[data-test-placement-failure-task-group]').map(title =>
+ title.textContent.trim()
+ );
+
+ failedTGAllocs.forEach(alloc => {
+ const name = alloc.get('name');
+ assert.ok(
+ taskGroupLabels.find(label => label.includes(name)),
+ `${name} included in placement failures list`
+ );
+ assert.ok(
+ taskGroupLabels.find(label => label.includes(alloc.get('coalescedFailures') + 1)),
+ 'The number of unplaced allocs = CoalescedFailures + 1'
+ );
+ });
+ });
+ });
+});
+
+test('when the job has no placement failures, the placement failures section is gone', function(assert) {
+ this.server.create('job', { noFailedPlacements: true, createAllocations: false });
+ this.store.findAll('job');
+
+ return wait().then(() => {
+ run(() => {
+ this.set('job', this.store.peekAll('job').get('firstObject'));
+ });
+
+ this.render(hbs`
+ {{job-page/parts/placement-failures job=job}})
+ `);
+
+ return wait().then(() => {
+ assert.notOk(find('[data-test-placement-failures]'), 'Placement failures section not found');
+ });
+ });
+});
diff --git a/ui/tests/integration/job-page/parts/running-deployment-test.js b/ui/tests/integration/job-page/parts/running-deployment-test.js
new file mode 100644
index 000000000..e6cb09bbd
--- /dev/null
+++ b/ui/tests/integration/job-page/parts/running-deployment-test.js
@@ -0,0 +1,141 @@
+import { getOwner } from '@ember/application';
+import { test, moduleForComponent } from 'ember-qunit';
+import { click, find } from 'ember-native-dom-helpers';
+import wait from 'ember-test-helpers/wait';
+import hbs from 'htmlbars-inline-precompile';
+import moment from 'moment';
+import { startMirage } from 'nomad-ui/initializers/ember-cli-mirage';
+import { initialize as fragmentSerializerInitializer } from 'nomad-ui/initializers/fragment-serializer';
+
+moduleForComponent(
+ 'job-page/parts/running-deployment',
+ 'Integration | Component | job-page/parts/running-deployment',
+ {
+ integration: true,
+ beforeEach() {
+ fragmentSerializerInitializer(getOwner(this));
+ window.localStorage.clear();
+ this.store = getOwner(this).lookup('service:store');
+ this.server = startMirage();
+ this.server.create('namespace');
+ },
+ afterEach() {
+ this.server.shutdown();
+ window.localStorage.clear();
+ },
+ }
+);
+
+test('there is no active deployment section when the job has no active deployment', function(assert) {
+ this.server.create('job', {
+ type: 'service',
+ noActiveDeployment: true,
+ createAllocations: false,
+ });
+
+ this.store.findAll('job');
+
+ return wait().then(() => {
+ this.set('job', this.store.peekAll('job').get('firstObject'));
+ this.render(hbs`
+ {{job-page/parts/running-deployment job=job}})
+ `);
+
+ return wait().then(() => {
+ assert.notOk(find('[data-test-active-deployment]'), 'No active deployment');
+ });
+ });
+});
+
+test('the active deployment section shows up for the currently running deployment', function(assert) {
+ this.server.create('job', { type: 'service', createAllocations: false, activeDeployment: true });
+
+ this.store.findAll('job');
+
+ return wait().then(() => {
+ this.set('job', this.store.peekAll('job').get('firstObject'));
+ this.render(hbs`
+ {{job-page/parts/running-deployment job=job}}
+ `);
+
+ return wait().then(() => {
+ const deployment = this.get('job.runningDeployment');
+ const version = deployment.get('version');
+
+ assert.ok(find('[data-test-active-deployment]'), 'Active deployment');
+ assert.equal(
+ find('[data-test-active-deployment-stat="id"]').textContent.trim(),
+ deployment.get('shortId'),
+ 'The active deployment is the most recent running deployment'
+ );
+
+ assert.equal(
+ find('[data-test-active-deployment-stat="submit-time"]').textContent.trim(),
+ moment(version.get('submitTime')).fromNow(),
+ 'Time since the job was submitted is in the active deployment header'
+ );
+
+ assert.equal(
+ find('[data-test-deployment-metric="canaries"]').textContent.trim(),
+ `${deployment.get('placedCanaries')} / ${deployment.get('desiredCanaries')}`,
+ 'Canaries, both places and desired, are in the metrics'
+ );
+
+ assert.equal(
+ find('[data-test-deployment-metric="placed"]').textContent.trim(),
+ deployment.get('placedAllocs'),
+ 'Placed allocs aggregates across task groups'
+ );
+
+ assert.equal(
+ find('[data-test-deployment-metric="desired"]').textContent.trim(),
+ deployment.get('desiredTotal'),
+ 'Desired allocs aggregates across task groups'
+ );
+
+ assert.equal(
+ find('[data-test-deployment-metric="healthy"]').textContent.trim(),
+ deployment.get('healthyAllocs'),
+ 'Healthy allocs aggregates across task groups'
+ );
+
+ assert.equal(
+ find('[data-test-deployment-metric="unhealthy"]').textContent.trim(),
+ deployment.get('unhealthyAllocs'),
+ 'Unhealthy allocs aggregates across task groups'
+ );
+
+ assert.equal(
+ find('[data-test-deployment-notification]').textContent.trim(),
+ deployment.get('statusDescription'),
+ 'Status description is in the metrics block'
+ );
+ });
+ });
+});
+
+test('the active deployment section can be expanded to show task groups and allocations', function(assert) {
+ this.server.create('node');
+ this.server.create('job', { type: 'service', activeDeployment: true });
+
+ this.store.findAll('job');
+
+ return wait().then(() => {
+ this.set('job', this.store.peekAll('job').get('firstObject'));
+ this.render(hbs`
+ {{job-page/parts/running-deployment job=job}}
+ `);
+
+ return wait().then(() => {
+ assert.notOk(find('[data-test-deployment-task-groups]'), 'Task groups not found');
+ assert.notOk(find('[data-test-deployment-allocations]'), 'Allocations not found');
+
+ click('[data-test-deployment-toggle-details]');
+
+ return wait().then(() => {
+ assert.ok(find('[data-test-deployment-task-groups]'), 'Task groups found');
+ assert.ok(find('[data-test-deployment-allocations]'), 'Allocations found');
+ });
+ });
+ });
+});
diff --git a/ui/tests/integration/job-page/parts/summary-test.js b/ui/tests/integration/job-page/parts/summary-test.js
new file mode 100644
index 000000000..186c4ffcf
--- /dev/null
+++ b/ui/tests/integration/job-page/parts/summary-test.js
@@ -0,0 +1,154 @@
+import { getOwner } from '@ember/application';
+import hbs from 'htmlbars-inline-precompile';
+import wait from 'ember-test-helpers/wait';
+import { find } from 'ember-native-dom-helpers';
+import { test, moduleForComponent } from 'ember-qunit';
+import { startMirage } from 'nomad-ui/initializers/ember-cli-mirage';
+import { initialize as fragmentSerializerInitializer } from 'nomad-ui/initializers/fragment-serializer';
+
+moduleForComponent('job-page/parts/summary', 'Integration | Component | job-page/parts/summary', {
+ integration: true,
+ beforeEach() {
+ fragmentSerializerInitializer(getOwner(this));
+ window.localStorage.clear();
+ this.store = getOwner(this).lookup('service:store');
+ this.server = startMirage();
+ this.server.create('namespace');
+ },
+ afterEach() {
+ this.server.shutdown();
+ window.localStorage.clear();
+ },
+});
+
+test('jobs with children use the children diagram', function(assert) {
+ this.server.create('job', 'periodic', {
+ createAllocations: false,
+ });
+
+ this.store.findAll('job');
+
+ return wait().then(() => {
+ this.set('job', this.store.peekAll('job').get('firstObject'));
+
+ this.render(hbs`
+ {{job-page/parts/summary job=job}}
+ `);
+
+ return wait().then(() => {
+ assert.ok(find('[data-test-children-status-bar]'), 'Children status bar found');
+ assert.notOk(find('[data-test-allocation-status-bar]'), 'Allocation status bar not found');
+ });
+ });
+});
+
+test('jobs without children use the allocations diagram', function(assert) {
+ this.server.create('job', {
+ createAllocations: false,
+ });
+
+ this.store.findAll('job');
+
+ return wait().then(() => {
+ this.set('job', this.store.peekAll('job').get('firstObject'));
+
+ this.render(hbs`
+ {{job-page/parts/summary job=job}}
+ `);
+
+ return wait().then(() => {
+ assert.ok(find('[data-test-allocation-status-bar]'), 'Allocation status bar found');
+ assert.notOk(find('[data-test-children-status-bar]'), 'Children status bar not found');
+ });
+ });
+});
+
+test('the allocations diagram lists all allocation status figures', function(assert) {
+ this.server.create('job', {
+ createAllocations: false,
+ });
+
+ this.store.findAll('job');
+
+ return wait().then(() => {
+ this.set('job', this.store.peekAll('job').get('firstObject'));
+
+ this.render(hbs`
+ {{job-page/parts/summary job=job}}
+ `);
+
+ return wait().then(() => {
+ assert.equal(
+ find('[data-test-legend-value="queued"]').textContent,
+ this.get('job.queuedAllocs'),
+ `${this.get('job.queuedAllocs')} are queued`
+ );
+
+ assert.equal(
+ find('[data-test-legend-value="starting"]').textContent,
+ this.get('job.startingAllocs'),
+ `${this.get('job.startingAllocs')} are starting`
+ );
+
+ assert.equal(
+ find('[data-test-legend-value="running"]').textContent,
+ this.get('job.runningAllocs'),
+ `${this.get('job.runningAllocs')} are running`
+ );
+
+ assert.equal(
+ find('[data-test-legend-value="complete"]').textContent,
+ this.get('job.completeAllocs'),
+ `${this.get('job.completeAllocs')} are complete`
+ );
+
+ assert.equal(
+ find('[data-test-legend-value="failed"]').textContent,
+ this.get('job.failedAllocs'),
+ `${this.get('job.failedAllocs')} are failed`
+ );
+
+ assert.equal(
+ find('[data-test-legend-value="lost"]').textContent,
+ this.get('job.lostAllocs'),
+ `${this.get('job.lostAllocs')} are lost`
+ );
+ });
+ });
+});
+
+test('the children diagram lists all children status figures', function(assert) {
+ this.server.create('job', 'periodic', {
+ createAllocations: false,
+ });
+
+ this.store.findAll('job');
+
+ return wait().then(() => {
+ this.set('job', this.store.peekAll('job').get('firstObject'));
+
+ this.render(hbs`
+ {{job-page/parts/summary job=job}}
+ `);
+
+ return wait().then(() => {
+ assert.equal(
+ find('[data-test-legend-value="queued"]').textContent,
+ this.get('job.pendingChildren'),
+ `${this.get('job.pendingChildren')} are pending`
+ );
+
+ assert.equal(
+ find('[data-test-legend-value="running"]').textContent,
+ this.get('job.runningChildren'),
+ `${this.get('job.runningChildren')} are running`
+ );
+
+ assert.equal(
+ find('[data-test-legend-value="complete"]').textContent,
+ this.get('job.deadChildren'),
+ `${this.get('job.deadChildren')} are dead`
+ );
+ });
+ });
+});
diff --git a/ui/tests/integration/job-page/parts/task-groups-test.js b/ui/tests/integration/job-page/parts/task-groups-test.js
new file mode 100644
index 000000000..f9ac811f8
--- /dev/null
+++ b/ui/tests/integration/job-page/parts/task-groups-test.js
@@ -0,0 +1,170 @@
+import { getOwner } from '@ember/application';
+import { assign } from '@ember/polyfills';
+import hbs from 'htmlbars-inline-precompile';
+import wait from 'ember-test-helpers/wait';
+import { click, findAll, find } from 'ember-native-dom-helpers';
+import { test, moduleForComponent } from 'ember-qunit';
+import sinon from 'sinon';
+import { startMirage } from 'nomad-ui/initializers/ember-cli-mirage';
+import { initialize as fragmentSerializerInitializer } from 'nomad-ui/initializers/fragment-serializer';
+
+moduleForComponent(
+ 'job-page/parts/task-groups',
+ 'Integration | Component | job-page/parts/task-groups',
+ {
+ integration: true,
+ beforeEach() {
+ fragmentSerializerInitializer(getOwner(this));
+ window.localStorage.clear();
+ this.store = getOwner(this).lookup('service:store');
+ this.server = startMirage();
+ this.server.create('namespace');
+ },
+ afterEach() {
+ this.server.shutdown();
+ },
+ }
+);
+
+const props = (job, options = {}) =>
+ assign(
+ {
+ job,
+ sortProperty: 'name',
+ sortDescending: true,
+ gotoTaskGroup: () => {},
+ },
+ options
+ );
+
+test('the job detail page should list all task groups', function(assert) {
+ this.server.create('job', {
+ createAllocations: false,
+ });
+
+ this.store.findAll('job').then(jobs => {
+ jobs.forEach(job => job.reload());
+ });
+
+ return wait().then(() => {
+ const job = this.store.peekAll('job').get('firstObject');
+ this.setProperties(props(job));
+
+ this.render(hbs`
+ {{job-page/parts/task-groups
+ job=job
+ sortProperty=sortProperty
+ sortDescending=sortDescending
+ gotoTaskGroup=gotoTaskGroup}}
+ `);
+
+ return wait().then(() => {
+ assert.equal(
+ findAll('[data-test-task-group]').length,
+ job.get('taskGroups.length'),
+ 'One row per task group'
+ );
+ });
+ });
+});
+
+test('each row in the task group table should show basic information about the task group', function(assert) {
+ this.server.create('job', {
+ createAllocations: false,
+ });
+
+ this.store.findAll('job').then(jobs => {
+ jobs.forEach(job => job.reload());
+ });
+
+ return wait().then(() => {
+ const job = this.store.peekAll('job').get('firstObject');
+ const taskGroup = job
+ .get('taskGroups')
+ .sortBy('name')
+ .reverse()
+ .get('firstObject');
+
+ this.setProperties(props(job));
+
+ this.render(hbs`
+ {{job-page/parts/task-groups
+ job=job
+ sortProperty=sortProperty
+ sortDescending=sortDescending
+ gotoTaskGroup=gotoTaskGroup}}
+ `);
+
+ return wait().then(() => {
+ const taskGroupRow = find('[data-test-task-group]');
+
+ assert.equal(
+ taskGroupRow.querySelector('[data-test-task-group-name]').textContent.trim(),
+ taskGroup.get('name'),
+ 'Name'
+ );
+ assert.equal(
+ taskGroupRow.querySelector('[data-test-task-group-count]').textContent.trim(),
+ taskGroup.get('count'),
+ 'Count'
+ );
+ assert.equal(
+ taskGroupRow.querySelector('[data-test-task-group-cpu]').textContent.trim(),
+ `${taskGroup.get('reservedCPU')} MHz`,
+ 'Reserved CPU'
+ );
+ assert.equal(
+ taskGroupRow.querySelector('[data-test-task-group-mem]').textContent.trim(),
+ `${taskGroup.get('reservedMemory')} MiB`,
+ 'Reserved Memory'
+ );
+ assert.equal(
+ taskGroupRow.querySelector('[data-test-task-group-disk]').textContent.trim(),
+ `${taskGroup.get('reservedEphemeralDisk')} MiB`,
+ 'Reserved Disk'
+ );
+ });
+ });
+});
+
+test('gotoTaskGroup is called when task group rows are clicked', function(assert) {
+ this.server.create('job', {
+ createAllocations: false,
+ });
+
+ this.store.findAll('job').then(jobs => {
+ jobs.forEach(job => job.reload());
+ });
+
+ return wait().then(() => {
+ const taskGroupSpy = sinon.spy();
+ const job = this.store.peekAll('job').get('firstObject');
+ const taskGroup = job
+ .get('taskGroups')
+ .sortBy('name')
+ .reverse()
+ .get('firstObject');
+
+ this.setProperties(
+ props(job, {
+ gotoTaskGroup: taskGroupSpy,
+ })
+ );
+
+ this.render(hbs`
+ {{job-page/parts/task-groups
+ job=job
+ sortProperty=sortProperty
+ sortDescending=sortDescending
+ gotoTaskGroup=gotoTaskGroup}}
+ `);
+
+ return wait().then(() => {
+ click('[data-test-task-group]');
+ assert.ok(
+ taskGroupSpy.withArgs(taskGroup).calledOnce,
+ 'Clicking the task group row calls the gotoTaskGroup action'
+ );
+ });
+ });
+});
diff --git a/ui/tests/integration/job-page/periodic-test.js b/ui/tests/integration/job-page/periodic-test.js
new file mode 100644
index 000000000..c259f0167
--- /dev/null
+++ b/ui/tests/integration/job-page/periodic-test.js
@@ -0,0 +1,86 @@
+import { getOwner } from '@ember/application';
+import { test, moduleForComponent } from 'ember-qunit';
+import { click, findAll } from 'ember-native-dom-helpers';
+import wait from 'ember-test-helpers/wait';
+import hbs from 'htmlbars-inline-precompile';
+import { startMirage } from 'nomad-ui/initializers/ember-cli-mirage';
+
+moduleForComponent('job-page/periodic', 'Integration | Component | job-page/periodic', {
+ integration: true,
+ beforeEach() {
+ window.localStorage.clear();
+ this.store = getOwner(this).lookup('service:store');
+ this.server = startMirage();
+ this.server.create('namespace');
+ },
+ afterEach() {
+ this.server.shutdown();
+ window.localStorage.clear();
+ },
+});
+
+test('Clicking Force Launch launches a new periodic child job', function(assert) {
+ const childrenCount = 3;
+
+ this.server.create('job', 'periodic', {
+ id: 'parent',
+ childrenCount,
+ createAllocations: false,
+ });
+
+ this.store.findAll('job');
+
+ return wait().then(() => {
+ const job = this.store.peekAll('job').findBy('plainId', 'parent');
+ this.setProperties({
+ job,
+ sortProperty: 'name',
+ sortDescending: true,
+ currentPage: 1,
+ gotoJob: () => {},
+ });
+
+ this.render(hbs`
+ {{job-page/periodic
+ job=job
+ sortProperty=sortProperty
+ sortDescending=sortDescending
+ currentPage=currentPage
+ gotoJob=gotoJob}}
+ `);
+
+ return wait().then(() => {
+ const currentJobCount = server.db.jobs.length;
+
+ assert.equal(
+ findAll('[data-test-job-name]').length,
+ childrenCount,
+ 'The new periodic job launch is in the children list'
+ );
+
+ click('[data-test-force-launch]');
+
+ return wait().then(() => {
+ const id = job.get('plainId');
+ const namespace = job.get('namespace.name') || 'default';
+
+ assert.ok(
+ server.pretender.handledRequests
+ .filterBy('method', 'POST')
+ .find(req => req.url === `/v1/job/${id}/periodic/force?namespace=${namespace}`),
+ 'POST URL was correct'
+ );
+
+ assert.ok(server.db.jobs.length, currentJobCount + 1, 'POST request was made');
+
+ return wait().then(() => {
+ assert.equal(
+ findAll('[data-test-job-name]').length,
+ childrenCount + 1,
+ 'The new periodic job launch is in the children list'
+ );
+ });
+ });
+ });
+ });
+});
diff --git a/website/source/api/agent.html.md b/website/source/api/agent.html.md
index 6172d2e02..b8b390fa6 100644
--- a/website/source/api/agent.html.md
+++ b/website/source/api/agent.html.md
@@ -279,6 +279,7 @@ $ curl \
"CirconusSubmissionInterval": "",
"CollectionInterval": "1s",
"DataDogAddr": "",
+ "DataDogTags": [],
"DisableHostname": false,
"PublishAllocationMetrics": false,
"PublishNodeMetrics": false,
diff --git a/website/source/api/operator.html.md b/website/source/api/operator.html.md
index 98226bfe9..edc6115de 100644
--- a/website/source/api/operator.html.md
+++ b/website/source/api/operator.html.md
@@ -168,9 +168,9 @@ $ curl \
"LastContactThreshold": "200ms",
"MaxTrailingLogs": 250,
"ServerStabilizationTime": "10s",
- "RedundancyZoneTag": "",
+ "EnableRedundancyZones": false,
"DisableUpgradeMigration": false,
- "UpgradeVersionTag": "",
+ "EnableCustomUpgrades": false,
"CreateIndex": 4,
"ModifyIndex": 4
}
@@ -221,19 +221,16 @@ The table below shows this endpoint's support for
cluster. Only takes effect if all servers are running Raft protocol version 3
or higher. Must be a duration value such as `30s`.
-- `RedundancyZoneTag` `(string: "")` - Controls the node-meta key to use when
- Autopilot is separating servers into zones for redundancy. Only one server in
- each zone can be a voting member at one time. If left blank, this feature will
- be disabled.
+- `EnableRedundancyZones` `(bool: false)` - (Enterprise-only) Specifies whether
+ to enable redundancy zones.
-- `DisableUpgradeMigration` `(bool: false)` - Disables Autopilot's upgrade
- migration strategy in Nomad Enterprise of waiting until enough
+- `DisableUpgradeMigration` `(bool: false)` - (Enterprise-only) Disables Autopilot's
+ upgrade migration strategy in Nomad Enterprise of waiting until enough
newer-versioned servers have been added to the cluster before promoting any of
them to voters.
-- `UpgradeVersionTag` `(string: "")` - Controls the node-meta key to use for
- version info when performing upgrade migrations. If left blank, the Nomad
- version will be used.
+- `EnableCustomUpgrades` `(bool: false)` - (Enterprise-only) Specifies whether to
+ enable using custom upgrade versions when performing migrations.
### Sample Payload
@@ -243,9 +240,9 @@ The table below shows this endpoint's support for
"LastContactThreshold": "200ms",
"MaxTrailingLogs": 250,
"ServerStabilizationTime": "10s",
- "RedundancyZoneTag": "",
+ "EnableRedundancyZones": false,
"DisableUpgradeMigration": false,
- "UpgradeVersionTag": "",
+ "EnableCustomUpgrades": false,
"CreateIndex": 4,
"ModifyIndex": 4
}
diff --git a/website/source/docs/agent/configuration/autopilot.html.md b/website/source/docs/agent/configuration/autopilot.html.md
index ed13f37aa..5328c0174 100644
--- a/website/source/docs/agent/configuration/autopilot.html.md
+++ b/website/source/docs/agent/configuration/autopilot.html.md
@@ -18,6 +18,7 @@ description: |-
The `autopilot` stanza configures the Nomad agent to configure Autopilot behavior.
+For more information about Autopilot, see the [Autopilot Guide](/guides/cluster/autopilot.html).
```hcl
autopilot {
@@ -25,9 +26,9 @@ autopilot {
last_contact_threshold = "200ms"
max_trailing_logs = 250
server_stabilization_time = "10s"
- redundancy_zone_tag = ""
- disable_upgrade_migration = true
- upgrade_version_tag = ""
+ enable_redundancy_zones = false
+ disable_upgrade_migration = false
+ enable_custom_upgrades = false
}
```
@@ -48,17 +49,17 @@ autopilot {
cluster. Only takes effect if all servers are running Raft protocol version 3
or higher. Must be a duration value such as `30s`.
-- `redundancy_zone_tag` `(string: "")` - Controls the node-meta key to use when
- Autopilot is separating servers into zones for redundancy. Only one server in
- each zone can be a voting member at one time. If left blank, this feature will
- be disabled.
+- `enable_redundancy_zones` `(bool: false)` - (Enterprise-only) Controls whether
+ Autopilot separates servers into zones for redundancy, in conjunction with the
+ [redundancy_zone](/docs/agent/configuration/server.html#redundancy_zone) parameter.
+ Only one server in each zone can be a voting member at one time.
-- `disable_upgrade_migration` `(bool: false)` - Disables Autopilot's upgrade
- migration strategy in Nomad Enterprise of waiting until enough
+- `disable_upgrade_migration` `(bool: false)` - (Enterprise-only) Disables Autopilot's
+ upgrade migration strategy in Nomad Enterprise of waiting until enough
newer-versioned servers have been added to the cluster before promoting any of
them to voters.
-- `upgrade_version_tag` `(string: "")` - Controls the node-meta key to use for
- version info when performing upgrade migrations. If left blank, the Nomad
- version will be used.
+- `enable_custom_upgrades` `(bool: false)` - (Enterprise-only) Specifies whether to
+ enable using custom upgrade versions when performing migrations, in conjunction with
+ the [upgrade_version](/docs/agent/configuration/server.html#upgrade_version) parameter.
diff --git a/website/source/docs/agent/configuration/server.html.md b/website/source/docs/agent/configuration/server.html.md
index 92854ae18..56b5e4abc 100644
--- a/website/source/docs/agent/configuration/server.html.md
+++ b/website/source/docs/agent/configuration/server.html.md
@@ -102,8 +102,9 @@ server {
second is a tradeoff as it lowers failure detection time of nodes at the
tradeoff of false positives and increased load on the leader.
-- `non_voting_server` `(bool: false)` - is whether this server will act as
- a non-voting member of the cluster to help provide read scalability. (Enterprise-only)
+- `non_voting_server` `(bool: false)` - (Enterprise-only) Specifies whether
+ this server will act as a non-voting member of the cluster to help provide
+ read scalability.
- `num_schedulers` `(int: [num-cores])` - Specifies the number of parallel
scheduler threads to run. This can be as many as one per core, or `0` to
@@ -120,6 +121,10 @@ server {
features and is typically not required as the agent internally knows the
latest version, but may be useful in some upgrade scenarios.
+- `redundancy_zone` `(string: "")` - (Enterprise-only) Specifies the redundancy
+ zone that this server will be a part of for Autopilot management. For more
+ information, see the [Autopilot Guide](/guides/cluster/autopilot.html).
+
- `rejoin_after_leave` `(bool: false)` - Specifies if Nomad will ignore a
previous leave and attempt to rejoin the cluster when starting. By default,
Nomad treats leave as a permanent intent and does not attempt to join the
@@ -149,6 +154,10 @@ server {
[server address format](#server-address-format) section for more information
on the format of the string.
+- `upgrade_version` `(string: "")` - A custom version of the format X.Y.Z to use
+ in place of the Nomad version when custom upgrades are enabled in Autopilot.
+ For more information, see the [Autopilot Guide](/guides/cluster/autopilot.html).
+
### Server Address Format
This section describes the acceptable syntax and format for describing the
diff --git a/website/source/docs/agent/configuration/telemetry.html.md b/website/source/docs/agent/configuration/telemetry.html.md
index b32af1e81..bf5b486e3 100644
--- a/website/source/docs/agent/configuration/telemetry.html.md
+++ b/website/source/docs/agent/configuration/telemetry.html.md
@@ -108,9 +108,15 @@ These `telemetry` parameters apply to
- `datadog_address` `(string: "")` - Specifies the address of a DataDog statsd
server to forward metrics to.
+- `datadog_tags` `(list: [])` - Specifies a list of global tags that will be
+ added to all telemetry packets sent to DogStatsD. It is a list of strings,
+ where each string looks like "my_tag_name:my_tag_value".
+
+
```hcl
telemetry {
datadog_address = "dogstatsd.company.local:8125"
+ datadog_tags = ["my_tag_name:my_tag_value"]
}
```
diff --git a/website/source/docs/drivers/docker.html.md b/website/source/docs/drivers/docker.html.md
index c75238dfd..99ef6de58 100644
--- a/website/source/docs/drivers/docker.html.md
+++ b/website/source/docs/drivers/docker.html.md
@@ -355,6 +355,9 @@ The `docker` driver supports the following configuration in the job spec. Only
]
}
```
+* `advertise_ipv6_address` - (Optional) `true` or `false` (default). Use the container's
+ IPv6 address (GlobalIPv6Address in Docker) when registering services and checks.
+ See [IPv6 Docker containers](/docs/job-specification/service.html#IPv6 Docker containers) for details.
* `readonly_rootfs` - (Optional) `true` or `false` (default). Mount
the container's filesystem as read only.
diff --git a/website/source/docs/job-specification/service.html.md b/website/source/docs/job-specification/service.html.md
index 54f429075..6d04e8132 100644
--- a/website/source/docs/job-specification/service.html.md
+++ b/website/source/docs/job-specification/service.html.md
@@ -463,6 +463,109 @@ In this case Nomad doesn't need to assign Redis any host ports. The `service`
and `check` stanzas can both specify the port number to advertise and check
directly since Nomad isn't managing any port assignments.
+### IPv6 Docker containers
+
+The [Docker](/docs/drivers/docker.html#advertise_ipv6_address) driver supports the
+`advertise_ipv6_address` parameter in it's configuration.
+
+Services will automatically advertise the IPv6 address when `advertise_ipv6_address`
+is used.
+
+Unlike services, checks do not have an `auto` address mode as there's no way
+for Nomad to know which is the best address to use for checks. Consul needs
+access to the address for any HTTP or TCP checks.
+
+So you have to set `address_mode` parameter in the `check` stanza to `driver`.
+
+For example using `auto` address mode:
+
+```hcl
+job "example" {
+ datacenters = ["dc1"]
+ group "cache" {
+
+ task "redis" {
+ driver = "docker"
+
+ config {
+ image = "redis:3.2"
+ advertise_ipv6_address = true
+ port_map {
+ db = 6379
+ }
+ }
+
+ resources {
+ cpu = 500 # 500 MHz
+ memory = 256 # 256MB
+ network {
+ mbits = 10
+ port "db" {}
+ }
+ }
+
+ service {
+ name = "ipv6-redis"
+ port = db
+ check {
+ name = "ipv6-redis-check"
+ type = "tcp"
+ interval = "10s"
+ timeout = "2s"
+ port = db
+ address_mode = "driver"
+ }
+ }
+ }
+ }
+}
+```
+
+Or using `address_mode=driver` for `service` and `check` with numeric ports:
+
+```hcl
+job "example" {
+ datacenters = ["dc1"]
+ group "cache" {
+
+ task "redis" {
+ driver = "docker"
+
+ config {
+ image = "redis:3.2"
+ advertise_ipv6_address = true
+ # No port map required!
+ }
+
+ resources {
+ cpu = 500 # 500 MHz
+ memory = 256 # 256MB
+ network {
+ mbits = 10
+ }
+ }
+
+ service {
+ name = "ipv6-redis"
+ port = 6379
+ address_mode = "driver"
+ check {
+ name = "ipv6-redis-check"
+ type = "tcp"
+ interval = "10s"
+ timeout = "2s"
+ port = 6379
+ address_mode = "driver"
+ }
+ }
+ }
+ }
+}
+```
+
+The `service` and `check` stanzas can both specify the port number to
+advertise and check directly since Nomad isn't managing any port assignments.
+
- - -
diff --git a/website/source/guides/acl.html.markdown b/website/source/guides/acl.html.markdown
index cf6788f38..b58b9eab1 100644
--- a/website/source/guides/acl.html.markdown
+++ b/website/source/guides/acl.html.markdown
@@ -370,3 +370,150 @@ Error bootstrapping: Unexpected response code: 500 (Invalid bootstrap reset inde
This is because the reset file is in place, but with the incorrect index.
The reset file can be deleted, but Nomad will not reset the bootstrap until the index is corrected.
+## Vault Integration
+Hashicorp Vault has a secret backend for generating short-lived Nomad tokens. As Vault has a number of
+authentication backends, it could provide a workflow where a user or orchestration system authenticates
+using an pre-existing identity service (LDAP, Okta, Amazon IAM, etc.) in order to obtain a short-lived
+Nomad token.
+
+~> Hashicorp Vault is a standalone product with it's own set of deployment and
+ configuration best practices. Please review [Vault's
+ documentation](https://www.vaultproject.io/docs/index.html) before deploying it
+ in production.
+
+For evaluation purposes, a Vault server in "dev" mode can be used.
+
+```
+$ vault server -dev
+==> Vault server configuration:
+
+ Cgo: disabled
+ Cluster Address: https://127.0.0.1:8201
+ Listener 1: tcp (addr: "127.0.0.1:8200", cluster address: "127.0.0.1:8201", tls: "disabled")
+ Log Level: info
+ Mlock: supported: false, enabled: false
+ Redirect Address: http://127.0.0.1:8200
+ Storage: inmem
+ Version: Vault v0.8.3
+ Version Sha: a393b20cb6d96c73e52eb5af776c892b8107a45d
+
+==> WARNING: Dev mode is enabled!
+
+In this mode, Vault is completely in-memory and unsealed.
+Vault is configured to only have a single unseal key. The root
+token has already been authenticated with the CLI, so you can
+immediately begin using the Vault CLI.
+
+The only step you need to take is to set the following
+environment variables:
+
+ export VAULT_ADDR='http://127.0.0.1:8200'
+
+The unseal key and root token are reproduced below in case you
+want to seal/unseal the Vault or play with authentication.
+
+Unseal Key: YzFfPgnLl9R1f6bLU7tGqi/PIDhDaAV/tlNDMV5Rrq0=
+Root Token: f84b587e-5882-bba1-a3f0-d1a3d90ca105
+```
+
+### Pre-requisites
+- Nomad ACL system bootstrapped.
+- A management token (the bootstrap token can be used, but for production
+ systems it's recommended to have a separate token)
+- A set of policies created in Nomad
+- An unsealed Vault server (Vault running in `dev` mode is unsealed
+ automatically upon startup)
+ - Vault must be version 0.9.3 or later to have the Nomad plugin
+
+### Configuration
+Mount the [`nomad`][nomad_backend] secret backend in Vault:
+
+```
+$ vault mount nomad
+Successfully mounted 'nomad' at 'nomad'!
+```
+
+Configure access with Nomad's address and management token:
+
+```
+$ vault write nomad/config/access \
+ address=http://127.0.0.1:4646 \
+ token=adf4238a-882b-9ddc-4a9d-5b6758e4159e
+Success! Data written to: nomad/config/access
+```
+
+Vault secret backends have the concept of roles, which are configuration units that group one or more
+Vault policies to a potential identity attribute, (e.g. LDAP Group membership). The name of the role
+is specified on the path, while the mapping to policies is done by naming them in a comma separated list,
+for example:
+
+```
+$ vault write nomad/role/role-name policy=policyone,policytwo
+Success! Data written to: nomad/roles/role-name
+```
+
+Similarly, to create management tokens, or global tokens:
+
+```
+$ vault write nomad/role/role-name type=management global=true
+Success! Data written to: nomad/roles/role-name
+```
+
+Create a Vault policy to allow different identities to get tokens associated with a particular
+role:
+
+```
+$ echo 'path "nomad/creds/role-name" {
+ capabilities = ["read"]
+}' | vault policy-write nomad-user-policy -
+Policy 'nomad-user-policy' written.
+```
+
+If you have an existing authentication backend (like LDAP), follow the relevant instructions to create
+a role available on the [Authentication backends page](https://www.vaultproject.io/docs/auth/index.html).
+Otherwise, for testing purposes, a Vault token can be generated associated with the policy:
+
+```
+$ vault token-create -policy=nomad-user-policy
+Key Value
+--- -----
+token deedfa83-99b5-34a1-278d-e8fb76809a5b
+token_accessor fd185371-7d80-8011-4f45-1bb3af2c2733
+token_duration 768h0m0s
+token_renewable true
+token_policies [default nomad-user-policy]
+```
+
+Finally obtain a Nomad Token using the existing Vault Token:
+
+```
+$ vault read nomad/creds/role-name
+Key Value
+--- -----
+lease_id nomad/creds/test/6fb22e25-0cd1-b4c9-494e-aba330c317b9
+lease_duration 768h0m0s
+lease_renewable true
+accessor_id 10b8fb49-7024-2126-8683-ab355b581db2
+secret_id 8898d19c-e5b3-35e4-649e-4153d63fbea9
+```
+
+Verify that the token is created correctly in Nomad, looking it up by its accessor:
+
+```
+$ nomad acl token info 10b8fb49-7024-2126-8683-ab355b581db2
+Accessor ID = 10b8fb49-7024-2126-8683-ab355b581db2
+Secret ID = 8898d19c-e5b3-35e4-649e-4153d63fbea9
+Name = Vault test root 1507307164169530060
+Type = management
+Global = true
+Policies = n/a
+Create Time = 2017-10-06 16:26:04.170633207 +0000 UTC
+Create Index = 228
+Modify Index = 228
+```
+
+Any user or process with access to Vault can now obtain short lived Nomad Tokens in order to
+carry out operations, thus centralising the access to Nomad tokens.
+
+
+[nomad_backend]: https://www.vaultproject.io/docs/secrets/nomad/index.html
diff --git a/website/source/guides/cluster/autopilot.html.md b/website/source/guides/cluster/autopilot.html.md
index 24e390cb0..15f650732 100644
--- a/website/source/guides/cluster/autopilot.html.md
+++ b/website/source/guides/cluster/autopilot.html.md
@@ -32,9 +32,9 @@ autopilot {
last_contact_threshold = 200ms
max_trailing_logs = 250
server_stabilization_time = "10s"
- redundancy_zone_tag = "az"
+ enable_redundancy_zones = false
disable_upgrade_migration = false
- upgrade_version_tag = ""
+ enable_custom_upgrades = false
}
```
@@ -49,21 +49,21 @@ CleanupDeadServers = true
LastContactThreshold = 200ms
MaxTrailingLogs = 250
ServerStabilizationTime = 10s
-RedundancyZoneTag = ""
+EnableRedundancyZones = false
DisableUpgradeMigration = false
-UpgradeVersionTag = ""
+EnableCustomUpgrades = false
-$ Nomad operator autopilot set-config -cleanup-dead-servers=false
+$ nomad operator autopilot set-config -cleanup-dead-servers=false
Configuration updated!
-$ Nomad operator autopilot get-config
+$ nomad operator autopilot get-config
CleanupDeadServers = false
LastContactThreshold = 200ms
MaxTrailingLogs = 250
ServerStabilizationTime = 10s
-RedundancyZoneTag = ""
+EnableRedundancyZones = false
DisableUpgradeMigration = false
-UpgradeVersionTag = ""
+EnableCustomUpgrades = false
```
## Dead Server Cleanup
@@ -164,15 +164,21 @@ isolated failure domains such as AWS Availability Zones; users would be forced t
have an overly-large quorum (2-3 nodes per AZ) or give up redundancy within an AZ by
deploying just one server in each.
-If the `RedundancyZoneTag` setting is set, Nomad will use its value to look for a
-zone in each server's specified [`-meta`](/docs/agent/configuration/client.html#meta)
-tag. For example, if `RedundancyZoneTag` is set to `zone`, and `-meta zone=east1a`
-is used when starting a server, that server's redundancy zone will be `east1a`.
+If the `EnableRedundancyZones` setting is set, Nomad will use its value to look for a
+zone in each server's specified [`redundancy_zone`]
+(/docs/agent/configuration/server.html#redundancy_zone) field.
Here's an example showing how to configure this:
+```hcl
+/* config.hcl */
+server {
+ redundancy_zone = "west-1"
+}
```
-$ nomad operator autopilot set-config -redundancy-zone-tag=zone
+
+```
+$ nomad operator autopilot set-config -enable-redundancy-zones=true
Configuration updated!
```
@@ -193,27 +199,25 @@ to voters and demoting the old servers. After this is finished, the old servers
safely removed from the cluster.
To check the Nomad version of the servers, either the [autopilot health]
-(/api/operator.html#read-health) endpoint or the `Nomad members`
+(/api/operator.html#read-health) endpoint or the `nomad members`
command can be used:
```
-$ Nomad members
-Node Address Status Type Build Protocol DC
-node1 127.0.0.1:8301 alive server 0.7.5 2 dc1
-node2 127.0.0.1:8703 alive server 0.7.5 2 dc1
-node3 127.0.0.1:8803 alive server 0.7.5 2 dc1
-node4 127.0.0.1:8203 alive server 0.8.0 2 dc1
+$ nomad server-members
+Name Address Port Status Leader Protocol Build Datacenter Region
+node1 127.0.0.1 4648 alive true 3 0.7.1 dc1 global
+node2 127.0.0.1 4748 alive false 3 0.7.1 dc1 global
+node3 127.0.0.1 4848 alive false 3 0.7.1 dc1 global
+node4 127.0.0.1 4948 alive false 3 0.8.0 dc1 global
```
### Migrations Without a Nomad Version Change
-The `UpgradeVersionTag` can be used to override the version information used during
+The `EnableCustomUpgrades` field can be used to override the version information used during
a migration, so that the migration logic can be used for updating the cluster when
changing configuration.
-If the `UpgradeVersionTag` setting is set, Nomad will use its value to look for a
-version in each server's specified [`-meta`](/docs/agent/configuration/client.html#meta)
-tag. For example, if `UpgradeVersionTag` is set to `build`, and `-meta build:0.0.2`
-is used when starting a server, that server's version will be `0.0.2` when considered in
-a migration. The upgrade logic will follow semantic versioning and the version string
+If the `EnableCustomUpgrades` setting is set to `true`, Nomad will use its value to look for a
+version in each server's specified [`upgrade_version`](/docs/agent/configuration/server.html#upgrade_version)
+tag. The upgrade logic will follow semantic versioning and the `upgrade_version`
must be in the form of either `X`, `X.Y`, or `X.Y.Z`.