Michael Klein 5de75550d3
ui: feature-flagged peering mvp (#13425)
* add peers route

* add peers to nav

* use regular app ui patterns peers template

* use empty state in peers UI

* mock `v1/peerings` request

* implement custom adapter/serializer for `peers`-model

* index request for peerings on peers route

* update peers list to show as proper list

* Use tailwind for easier styling

* Unique ids in peerings response mock-api

* Add styling peerings list

* Allow creating empty tooltip

To make it easier to iterate over a set of items where some items
should not display a tooltip and others should.

* Add tooltip Peerings:Badge

* Add undefined peering state badge

* Remove imported/exported services count peering

This won't be included in the initial version of the API response

* Implement Peerings::Search

* Make it possible to filter peerings by name

* Install ember-keyboard

For idiomatic handling of key-presses.

* Clear peering search input when pressing `Escape`

* use peers.index instead of peers for peerings listing

* Allow to include peered services in services-query

* update services mock to add peerName

* add Consul::Peer component

To surface peering information on a resource

* add PeerName as attribute to service model

* surface peering information in service list

* Add tooltip to Consul::Peer

* Make services searchable by peer-name

* Allow passing optional query-params to href-to

* Add peer query-param to dc.services.show

* Pass peer as query-param services listing

* support option peer route-param

* set peer-name undefined in services serializer when empty

* update peer route-param when navigating to peered service

* request sercice with peer-name if need be

* make sure to reset peer route-param when leaving service.show

* componentize services.peer-info

* surface peer info services.show

* make sure to reset peer route-param in main nav

* fix services breadcrumb services.intentions

we need to reset peer route-param here to not break the app

* surface peer when querying for it on service api call

* query for peer info service-instance api calls

* surface peer info service-instance.show

* Camelize peer attributes to match rest of app

* Refactor peers.index to reflect camelized attributes for peer

* Remove unused query-params services.show

* make logo href reset peer route-param

* Cleanup optional peer param query service-instance

* Use replace decorator instead of serializer for empty peerName

* make sure to only send peer info when correct qp is passed

* Always send qp for querying peers services request

* rename with-imports to with-peers

* Use css for peer-icon

* Refactor bucket-list component to surface peer-info

* Remove Consul::Peer component

This info is now displayed via the bucket-list component

* Fix bucket-list component to surface service again

* Update bucket-list docs to reflect peer-info addition

* Remove tailwind related styles

* Remove consul-tailwind package

We won't be using tailwind for now

* Fix typo badge scss

* Add with-import handling mock-api nodes

* Add peerName to node attributes

* include peers when querying nodes

* reflect api updates node list mock

* Create consul::node::peer-info component

* Surface peer-info in nodes list

* Mock peer response for node request

* Make it possible to add peer-name to node request

* Update peer route-param when linking to node

* Reset peers route-param when leaving nodes.show

We need to reset the route-param to not introduce a bug - otherwise
subsequent node show request would request with the old peer query-param

* Add sourcePeer intentions api mock

* add SourcePeer attr to intentions model

* Surface peering info on intentions list

* Request peered intentions differently intentions.edit

* Handle peer info in intentions/exact mock

* Surface peering info intention view

* Add randomized peer data topology mock

* Surface peer info topology view

* fix service/peer-info styling

We aren't using tailwind anymore - we need to create a custom scss file

* Update peerings api mocks

* Update peerings::badge with updated styling

* cleanup intentions/exact mock

* Create watcher component to declaratively register polling

* Poll peers in background when on peers route

* use existing colors for peering-badge

* Add test for requesting service with `with-peers`-query

* add imported/exported count to peers model

* update mock-api to surface exported/imported count on peers

* Show exported/imported peers count on peers list

* Use translations for service import/export UI peers

* Make sure to ask for nodes with peers

* Add match-url step for easier url testing of service urls

* Add test for peer-name on peered services

* Add test for service navigation peered service

* Implement feature-flag handling

* Enable peering feature in test and development

* Redirect peers to services.index when feature-flag is disabled

* Only query for peers when feature is enabled

* Only show peers in nav when feature is enabled

* Componentize peering service count detail

* Handle non-state Peerings::Badge

* Use Peerings::ServiceCount in peerings list

* Only send peer query for peered service-instances.

* Add step to visit url directly

* add test for accessing peered service directly

* Remove unused service import peers.index

* Only query for peer when peer provided node-adapter

* fix tests
2022-06-23 14:16:26 +01:00

193 lines
7.2 KiB
Plaintext

[
${
range(
env(
'CONSUL_NODE_COUNT',
Math.floor(
(
Math.random() * env('CONSUL_NODE_MAX', 10)
) + parseInt(env('CONSUL_NODE_MIN', 1))
)
)
).map(
function(item, i)
{
const node = `node-${i}`;
const service = location.pathname.slice(4);
const ip = fake.internet.ip();
const proxy = service.indexOf('-proxy')
const sidecar = service.indexOf('-sidecar-proxy')
const id = (proxy !== -1 ? service.slice(0, -6) + '-with-id-proxy' : service + '-with-id');
let kind = '';
switch(true) {
case service.endsWith('-mesh-gateway'):
kind = 'mesh-gateway';
break;
case service.endsWith('-terminating-gateway'):
kind = 'terminating-gateway';
break;
case service.endsWith('-ingress-gateway'):
kind = 'ingress-gateway';
break;
case service.endsWith('-proxy'):
kind = 'connect-proxy';
break;
}
return `
{
"Node":{
"ID":"7037e928-d9e8-3b58-4712-6f5ded209002",
"Node":"${node}",
"Address":"${ip}",
"Datacenter":"dc1",
"TaggedAddresses":{"lan":"${ip}","wan":"${ip}"},
"Meta":{"${service}-network-segment":""},
${typeof location.search.peer !== 'undefined' ? `
"PeerName": "${location.search.peer}",
` : ``}
"CreateIndex":5,
"ModifyIndex":6
},
"Service":{
"ID": "${ i === 0 ? id : fake.helpers.randomize([service, service + '-ID'])}",
${typeof location.search.peer !== 'undefined' ? `
"PeerName": "${location.search.peer}",
` : ``}
"Service":"${service}",
${typeof location.search.ns !== 'undefined' ? `
"Namespace": "${location.search.ns}",
` : ``}
${typeof location.search.partition !== 'undefined' ? `
"Partition": "${fake.helpers.randomize([env('CONSUL_PARTITION_EXPORTER', location.search.partition), location.search.partition])}",
` : ``}
"Tags":[
${
range(
env(
'CONSUL_TAG_COUNT',
Math.floor(
(
Math.random() * env('CONSUL_TAG_MAX', 10)
) + parseInt(env('CONSUL_TAG_MIN', 1))
)
)
).map(
function(item, i)
{
return `"${fake.hacker.noun()}"`;
}
)
}
],
"Weights": {
"Passing": 1,
"Warning": 1
},
${ fake.random.number({min: 1, max: 10}) > 2 ? `
"Meta": {
"consul-dashboard-url": "${fake.internet.protocol()}://${fake.internet.domainName()}/?id={{Service}}",
"external-source": "${fake.helpers.randomize(['consul-api-gateway', 'vault', 'consul', 'nomad', 'terraform', 'kubernetes', 'aws', ''])}"
},
` : `
"Meta": null,
` }
${ false ? `
"Address":"${fake.internet.ip()}",
"Port":${fake.random.number({min: 0, max: 65535})},
` : `
"Address":"",
"SocketPath": "/${fake.lorem.words(fake.random.number({min: 1, max: 5})).split(' ').join('/')}${fake.random.boolean() ? fake.system.fileName() : ''}",
` }
"Connect": {},
${kind !== '' ? `
"Kind": "${kind}",
` : `` }
"Proxy": {
${proxy !== -1 && sidecar === -1 ? `
"DestinationServiceName": "${service.substr(0, proxy)}",
` : `
"Expose": {},
"MeshGateway": {},
"Mode": "",
"TransparentProxy": ""
`}
${sidecar !== -1 ? `
"DestinationServiceName": "${service.substr(0, sidecar)}",
"DestinationServiceID": "${service.substr(0, sidecar)}-ID",
"LocalServiceAddress": "${fake.internet.ip()}",
"LocalServicePort": ${fake.random.number({min: 0, max: 65535})},
` : ``}
${proxy !== -1 ? `
"Expose": {
"Checks": true,
"Paths": [
${range(env('CONSUL_EXPOSED_COUNT', 3)).map((i) => `
{
"Path": "/${fake.lorem.words(fake.random.number({min: 1, max: 5})).split(' ').join('/')}${fake.random.boolean() ? fake.system.fileName() : ''}",
"Protocol": "${fake.helpers.randomize(['http', 'http2', 'grpc'])}",
"LocalPathPort": ${fake.random.number({min: 0, max: 65535})},
"ListenerPort": ${fake.random.number({min: 0, max: 65535})}
}
`)}
]
},
"Upstreams": [
${range(env('CONSUL_UPSTREAM_COUNT', 10)).map((item, j) => `
{
"Datacenter": "${fake.address.countryCode().toLowerCase()} ${ i % 2 ? "west" : "east"}-${j}",
"DestinationName": "${fake.hacker.noun()}",
"DestinationNamespace": "${fake.hacker.noun()}",
"DestinationPartition": "${fake.hacker.noun()}",
"DestinationType": "${fake.helpers.randomize(['service', 'prepared_query'])}",
${fake.random.number({min: 1, max: 10}) > 5 ? `
"LocalBindAddress": "${fake.internet.ip()}",
"LocalBindPort": ${fake.random.number({min: 0, max: 65535})}
` : `
"LocalBindSocketMode": "0600",
"LocalBindSocketPath": "/${fake.lorem.words(fake.random.number({min: 1, max: 5})).split(' ').join('/')}${fake.random.boolean() ? fake.system.fileName() : ''}"
` }
}
`)}
]
` : ``}
},
"ProxyDestination": "",
"EnableTagOverride":false,
"CreateIndex":5,
"ModifyIndex":5
},
"Checks":[
${
range(env('CONSUL_CHECK_COUNT', 10)).map(
function(item, j) {
const passing = i > 7 || j > fake.random.number(4);
const id = fake.helpers.randomize([service, '']);
return `
{
"Node":"${node}",
"CheckID":"${fake.hacker.noun()}Health",
"Name":"${fake.hacker.noun()} Status",
"Type": "${j === 0 ? 'ttl' : (j === 1 ? 'http' : fake.helpers.randomize(['script', 'http', 'tcp', 'ttl', 'docker', 'grpc', 'alias']))}",
"Status":"${j < 2 ? 'critical' : (passing ? "passing" : fake.helpers.randomize(['warning', 'critical']))}",
"Notes":"${fake.lorem.paragraph()}",
"Output":"${fake.internet.ipv6()} ${fake.internet.protocol()}://${fake.internet.userName()}:${fake.internet.password()}@${fake.internet.domainName()} ${fake.internet.userAgent()}",
"ServiceID":"${j < 2 ? service : id}",
"ServiceName":"",
"ServiceTags":["Tag"],
"Definition":{},
"CreateIndex":5,
"ModifyIndex":5
}
`;
}
)
}
]
}
`;
}
)
}
]