1${
2	[1].map(() => {
3
4  	const namespaces = ['default'];
5  	const ns = location.search.ns || 'default';
6  	const dc = location.search.dc;
7  	const service = location.pathname.get(2);
8
9    const routeCount = env(
10      'CONSUL_ROUTE_COUNT',
11      Math.floor(
12        (
13          Math.random() * env('CONSUL_ROUTE_MAX', 10)
14        ) + parseInt(env('CONSUL_ROUTE_MIN', 1))
15      )
16    );
17    const headerCount = env(
18      'CONSUL_HEADER_COUNT',
19      Math.floor(
20        (
21          Math.random() * env('CONSUL_HEADER_MAX', 3)
22        ) + parseInt(env('CONSUL_HEADER_MIN', 1))
23      )
24    );
25
26    const queryParamCount = env(
27      'CONSUL_QUERYPARAM_COUNT',
28      Math.floor(
29        (
30          Math.random() * env('CONSUL_QUERYPARAM_MAX', 3)
31        ) + parseInt(env('CONSUL_QUERYPARAM_MIN', 1))
32      )
33    );
34
35    const resolverCount = env(
36      'CONSUL_RESOLVER_COUNT',
37      Math.floor(
38        (
39          Math.random() * env('CONSUL_RESOLVER_MAX', 10)
40        ) + parseInt(env('CONSUL_RESOLVER_MIN', 1))
41      )
42    );
43    const redirectCount = env(
44      'CONSUL_REDIRECT_COUNT',
45      Math.floor(
46        (
47          Math.random() * env('CONSUL_REDIRECT_MAX', resolverCount)
48        ) + parseInt(env('CONSUL_REDIRECT_MIN', 0))
49      )
50    );
51    const splitterCount = env(
52      'CONSUL_SPLITTER_COUNT',
53      Math.floor(
54        (
55          Math.random() * env('CONSUL_SPLITTER_MAX', 5)
56        ) + parseInt(env('CONSUL_SPLITTER_MIN', 1))
57      )
58    );
59    const splitCount = env(
60      'CONSUL_SPLIT_COUNT',
61      Math.floor(
62        (
63          Math.random() * env('CONSUL_SPLIT_MAX', 10)
64        ) + parseInt(env('CONSUL_SPLIT_MIN', 1))
65      )
66    );
67
68
69
70
71    // make some resolvers
72		let resolvers = range(
73  	  resolverCount
74  	).map(() => {
75  	  const service = fake.hacker.noun().split(' ').join('-');
76  	  return {
77  	    ServiceName: service,
78			  Name: `${service}.${ns}.${dc}`,
79			  Subsets: range(
80    			  env(
81      			  'CONSUL_SUBSET_COUNT',
82      			  Math.floor(
83        			  (
84          			  Math.random() * env('CONSUL_SUBSET_MAX', 3)
85        			  ) + parseInt(env('CONSUL_SUBSET_MIN', 1))
86      			  )
87    			  )
88  			  ).map((item) => `v${item + 1}`)
89  	  };
90  	});
91
92    // make some redirects
93		const redirects = range(
94  	  redirectCount
95  	).map((item, i) => {
96  	  const service = resolvers[i].ServiceName;
97  	  return {
98  	    ServiceName: service,
99			  Name: `${service}.${ns}.redirect-${dc}`,
100			  Subsets: []
101  	  };
102  	});
103
104    // make some resolver targets with possible subsets
105		let resolverTargets = resolvers.reduce(
106			function(prev, resolver) {
107				const targets = [`${resolver.Name}`];
108				return prev.concat(targets.concat(
109					resolver.Subsets.map(
110						function(item) {
111							return `${item}.${targets[0]}`
112						}
113					)
114				).map(
115					(item) => `resolver:${item}`
116				));
117			},
118			[]
119		);
120		const redirectTargets = redirects.map(
121			function(item) {
122				return `resolver:${item.Name}`;
123			}
124		);
125
126    resolverTargets = resolverTargets.concat(redirectTargets);
127  	resolvers = resolvers.concat(redirects);
128
129		const splitters = range(
130  	  splitterCount
131  	).map(() => ({
132			Name: `${service}-${fake.hacker.noun()}.${ns}`,
133			Splits: range(
134  		  splitCount
135  		).map((item, i, arr) => ({
136        "Weight": 100 / arr.length,
137        "NextNode": fake.helpers.randomize(resolverTargets)
138      }))
139		}));
140
141
142		const splitterTargets = splitters.map(
143			function(item) {
144				return `splitter:${item.Name}`;
145			}
146		);
147
148		const nextNodes = resolverTargets.concat(splitterTargets);
149		return `
150{
151  "Chain": {
152    "ServiceName": "${service}",
153    "Namespace": "${ns}",
154    "Datacenter": "${dc}",
155    "Protocol": "http",
156    "StartNode": "router:${service}",
157    "Nodes": {
158
159      "router:${service}": {
160        "Type": "router",
161        "Name": "${service}",
162        "Routes": [
163${
164  range(
165    routeCount
166  ).map((item, i) => {
167		const path = fake.helpers.randomize(['PathExact', 'PathPrefix', 'PathRegex', '']);
168		const splitter = fake.helpers.randomize(splitters);
169		const nextNode = fake.helpers.randomize(nextNodes);
170		return `
171          {
172            "NextNode": "${nextNode}",
173            "Definition": {
174              "Match": {
175                "HTTP": {
176${ path !== '' ? `
177                  "${path}": "${path === 'PathRegex' ? `${fake.helpers.randomize(['^[0-9]{1,3}?$', '(\w+)\s(\w+)'])}` : `/${fake.lorem.words(fake.random.number({min: 1, max: 5})).split(' ').join('/')}${fake.random.boolean() ? fake.system.fileName() : ''}`}"
178` : `"": ""`}
179${ fake.random.boolean() ? `
180                  ,"Header": [
181${
182	range(
183	  headerCount
184	).map(item => `
185										{
186											"Name": "X-${fake.hacker.noun().split(' ').map(item => `${item.substr(0, 1).toUpperCase()}${item.substr(1)}`).join('-')}",
187	${fake.random.boolean() ? `
188											"Invert": true,
189			` : ``
190	}
191	${fake.helpers.randomize([
192											'"Present": true',
193											'"Exact": true',
194											'"Prefix": "abc"',
195											'"Suffix": "xyz"',
196											'"Regex": "[abc]"'
197	])}
198										}
199	`)}
200                  ]
201` : ``}
202${ fake.random.boolean() ? `
203                  ,"QueryParam": [
204${
205	range(
206	  queryParamCount
207	).map(item => `
208										{
209											"Name": "${fake.hacker.noun().split(' ').join('-')}",
210	${fake.helpers.randomize([
211											'"Present": true',
212											'"Exact": true',
213											'"Prefix": "abc"',
214											'"Suffix": "xyz"',
215											'"Regex": "[abc]"'
216	])}
217										}
218	`)}
219                  ]
220` : ``}
221${ fake.random.boolean() ? `
222                  ,"Methods": [
223										${
224											fake.helpers.shuffle(
225												["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD", "PATCH"]
226											).filter(item => fake.random.boolean()).map(item => `
227												"${item}"
228											`)
229										}
230									]
231` : ``}
232                }
233              },
234              "Destination": {
235                "Service": "${nextNode}",
236                "PrefixRewrite": "/"
237              }
238            }
239          }
240`;})}
241        ]
242      },
243${resolvers.map((resolver) => {
244	const failoverCount = env(
245    'CONSUL_FAILOVER_COUNT',
246    fake.helpers.randomize([0, 0, 0, 0, 0, 1, 2, 3])
247  );
248	const failover = ({
249	  Datacenter: `${resolver.Name.replace(`.${dc}`, `.fail-${dc}`).replace(`.redirect-${dc}`, `.fail-${dc}`)}`,
250	  Namespace: `${resolver.Name.replace(`.${ns}.`, `.fail-${ns}.`).replace(`.redirect-${ns}.`, `.fail-${ns}.`)}`,
251	})[env('CONSUL_FAILOVER_TYPE', 'Datacenter')];
252
253	return `
254			"resolver:${resolver.Name}": {
255        "Type": "resolver",
256      	"Name": "${resolver.Name}",
257        "Resolver": {
258          "ConnectTimeout": "5s",
259${failoverCount > 0 ? `
260          "Failover": {
261            "Targets": [
262  ${range(failoverCount).map(item => `
263              "${failover.replace('fail-', `fail-${item + 1}-`)}"
264	`)}
265            ]
266          },
267` : `` }
268          "Target": "${resolver.Name}"
269        }
270			}${resolver.Subsets.length > 0 ? ',' : ''}
271${resolver.Subsets.map((subset) => {
272		const id = `${subset}.${resolver.Name}`;
273	  const failover = ({
274	    Datacenter: `${subset}.${resolver.Name.replace(`.${dc}`, `.fail-${dc}`)}`,
275	    Namespace: `${subset}.${resolver.Name.replace(`.${ns}.`, `.fail-${ns}.`)}`,
276	  })[env('CONSUL_FAILOVER_TYPE', 'Datacenter')];
277
278				return `
279      		"resolver:${id}": {
280        		"Type": "resolver",
281        		"Name": "${id}",
282        		"Resolver": {
283          		"ConnectTimeout": "5s",
284${failoverCount > 0 ? `
285              "Failover": {
286                "Targets": [
287  ${range(failoverCount).map(item => `
288                  "${failover.replace('fail-', `fail-${item + 1}-`)}"
289	`)}
290                ]
291              },
292` : `` }
293          		"Target": "${id}"
294        		}
295      		}
296				`;
297			})}
298`})},
299${splitters.map((item, i) => `
300      "splitter:${item.Name}": {
301        "Type": "splitter",
302        "Name": "${item.Name}",
303        "Splits": [
304  ${item.Splits.map(item => `
305    			{
306      			"Weight": ${item.Weight},
307      			"NextNode": "${item.NextNode}"
308    			}
309	`)}
310        ]
311      }
312`)}
313    },
314    "Targets": {
315${resolvers.map(item => {
316  const uuid = fake.random.uuid();
317  const domain = 'consul';
318	const name = `${item.Name}.internal.${uuid}.${domain}`;
319	return `
320		"${item.Name}": {
321      	"ID": "${item.Name}",
322      	"Service": "${item.ServiceName}",
323      	"Namespace": "${ns}",
324      	"Datacenter": "${dc}",
325      	"MeshGateway": {},
326      	"SNI": "${name}",
327      	"Name": "${name}"
328		}${item.Subsets.length > 0 ? ',' : ''}
329${item.Subsets.map(ktem => {
330		const id = `${ktem}.${item.Name}`;
331		const name = `${id}.internal.${uuid}.${domain}`;
332			return `
333      		"${id}": {
334        		"ID": "${id}",
335        		"Service": "${item.ServiceName}",
336        		"ServiceSubset": "${ktem}",
337        		"Namespace": "${ns}",
338        		"Datacenter": "${dc}",
339        		"MeshGateway": {
340        		},
341        		"Subset": {
342          		"Filter": "Service.Meta.value == ${ktem}"
343        		},
344        		"SNI": "${name}",
345        		"Name": "${name}"
346      		}
347			`})}
348`})}
349    }
350  }
351}
352`})}
353