8 |
9 |
10 |
11 | There are 2 methods to configure BIG-IP BlueGreen:
12 | * A web user interface
13 | * Declarative REST API
14 |
15 | A BlueGreen traffic distribution rule consists of 5 elements:
16 | 1. **name** - The name of the BlueGreen declaration. This is used as a unique key for creation, modification and deletion of BlueGreen declarations.
17 |
18 | 2. **virtualServer** - The full path of the virtual server. There may only be a single BlueGreen traffic distribution rule per virtual server. The full path can consist of a partition followed by virtual server name, or can contain partition name, application name and virtual server name.
19 | Examples:
20 | * /Common/VirtualServer
21 | * /DVWA/Application1/serviceMain (this format is common when using an [Application Services 3](https://clouddocs.f5.com/products/extensions/f5-appsvcs-extension/latest/) declaration)
22 |
23 | 3. **distribution** - A decimal value between 0.0 and 1.0 representing the amount of clients to direct to the _Blue_ pool. Think of this value as a percentage. In fact, it is expressed this way in the BlueGreen UI. The remainder of the distribution percentage is used to represent the percentage of traffic that will be directed to the _Green_ pool. Example: with a distribution value of 0.2, **20%** of clients will be directed to the pool identified as **bluePool**; the remaining **80%** of clients will be directed to the **greenPool**.
24 |
25 | 4. **bluePool** - The full path to a pool that typically represents a collection of servers running an _older_ version of an application. The full path of a pool can consist of a partition followed by a pool name, or can contain partition name, application name and pool name.
26 | Examples:
27 | * /Common/blue_pool
28 | * /DVWA/Application1/web_pool (this format is common when using an [Application Services 3](https://clouddocs.f5.com/products/extensions/f5-appsvcs-extension/latest/) declaration)
29 |
30 | 5. **greenPool** - The full path to a pool that typically represents a collection of servers running an _newer_ version of an application. The full path of a pool can consist of a partition followed by a pool name, or can contain partition name, application name and pool name.
31 | Examples:
32 | * /Common/green_pool
33 | * /DVWA/Application1/web_pool (this format is common when using an [Application Services 3](https://clouddocs.f5.com/products/extensions/f5-appsvcs-extension/latest/) declaration)
34 |
35 |
36 | ## Compatibility
37 | Though not exhaustively tested on all BIG-IP versions, this solution has been reported to work on versions 13.0 - 15.0.
38 |
39 | ## Installation
40 |
41 | ### Installation Via BIG-IP UI
42 |
43 | 1. Download the latest RPM package from the [dist](dist/) directory.
44 |
45 | 2. To view installed iControl LX Extensions in the BIG-IP GUI you must first enable this functionality. To do this, log in via SSH into the system with an `admin` account and execute `touch /var/config/rest/iapps/enable`. No reboot is required. This will enable the **iApps ‣ Package Management LX** menu:
46 |
47 | 
48 |
49 | 2. Upload and install the RPM package on the using the BIG-IP GUI:
50 |
51 | * **Main tab > iApps > Package Management LX > Import**
52 | * Select the downloaded file and click **Upload**
53 |
54 | 
55 |
56 | 3. Be sure to see the [known issues list](https://github.com/aknot242/bigip-blue-green/issues) to review any known issues and other important information before you attempt to use BIG-IP BlueGreen.
57 |
58 |
59 | ### Installation Via Command Line
60 |
61 | Use [directions](https://clouddocs.f5.com/products/extensions/f5-appsvcs-extension/latest/userguide/installation.html#installcurl-ref) provided by the Application Services 3 project as a reference to install BIG-IP BlueGreen via cURL.
62 |
63 |
64 | ## Usage
65 |
66 | ### Limitations
67 | * Since the current implementation uses a form of cookie persistence, the configured Virtual Server must utilize an HTTP Profile. If an HTTP Profile is not set for a Virtual Server, this Virtual Server will not appear in the user interface, and any declarations using this Virtual Server will not be permitted when using the API.
68 | * Virtual servers in custom partitions can only be configured to utilize pools in their own partition, or in the **Common** partition.
69 |
70 | ### UI
71 | 1. Log into a BIG-IP that has BIG-IP BlueGreen installed
72 | 2. Navigate to https://bigip-hostname/iapps/bigip-blue-green
73 |
74 |
75 | ### API
76 | * Included is a [Postman collection](BigIpBlueGreen.postman_collection.json) for references to post declarations to BIG-IP BlueGreen. You can download Postman [here](https://www.getpostman.com/downloads/).
77 |
78 | * To use the API, you must retrieve a BIG-IP authorization token and include it as a header value in all requests. The token can be retrieved by following the directions as indicated [here](https://devcentral.f5.com/articles/demystifying-icontrol-rest-part-6-token-based-authentication). An example of retrieving the token can also be found in the [Postman collection](BigIpBlueGreen.postman_collection.json) of this project. Once the authorization token has been retrieved, it must be inserted as a value into a header named **X-F5-Auth-Token** for all BlueGreen API requests.
79 | * The API supports **GET**, **POST** and **DELETE** REST methods:
80 | * **GET** to retrieve all or specific BlueGreen declarations.
81 | * **POST** to create and modify BlueGreen declarations
82 | * **DELETE** to permanently remove them.
83 |
84 | #### Example Operations
85 | * `POST` to `https://
107 |
108 | #### Declaration details page
109 | 
110 |
111 | ### Using the API to POST a declaration using Postman
112 | 
113 |
114 | ## RPM Package Build
115 | Building the project requires Docker to be installed on the host system. The build script is a bash script that can be invoked from the project root by executing `build/build.sh` in a terminal. Once the build is successful, the RPM and sha256 file can be found in `build/rpmbuild/RPMS/noarch`.
116 |
117 | ## Load Testing
118 | This project uses the [Locust](https://locust.io/) framework. For ease of setup and execution, [Docker](https://www.docker.com/) is utilized to host the testing runtime. Make sure Docker is installed on your host. Update the content checks in the [locustfile.py](load/locustfile.py) and update the URL in [run-load-test.sh](load/run-load-test.sh). To execute:
119 | ```
120 | cd load
121 | ./run-load-test.sh
122 | ```
123 | Once the Docker container is running, open http://localhost:8089/ in your browser to configure the load test parameters.
124 |
125 | ## Credits
126 | - Many thanks to [npearce](https://github.com/npearce) for helping me understand the possibilities in management/control plane extensibility of the BIG-IP platform as well as helping me through some of the less-traveled areas of the iControl LX APIs :). Check out some of his other projects such as [BigStats](https://github.com/f5devcentral/BigStats) and [CaC-Github_Webhook_Server](https://github.com/f5devcentral/CaC-Github_Webhook_Server)!
127 | - Core load balancing logic based on [Kevin Davies](https://devcentral.f5.com/s/profile/0051T000008OtS0QAK)' [rand function solution](https://devcentral.f5.com/s/feed/0D51T00006i7MabSAE) on [F5 DevCentral](https://devcentral.f5.com)
128 | - Icon based on a rotated version of https://commons.wikimedia.org/wiki/File:Blue_green_cyan_nevit_116.svg
129 |
--------------------------------------------------------------------------------
/api/.eslintrc.json:
--------------------------------------------------------------------------------
1 | {
2 | "extends": "standard",
3 | "rules": {
4 | "semi": [
5 | 2,
6 | "always"
7 | ]
8 | },
9 | "env": {
10 | "node": true,
11 | "mocha": true
12 | }
13 | }
--------------------------------------------------------------------------------
/api/manifest.json:
--------------------------------------------------------------------------------
1 | {"tags":["PLUGIN"]}
2 |
--------------------------------------------------------------------------------
/api/nodejs/apiClient.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | const fs = require('fs');
3 | const path = require('path');
4 | const handlebars = require('handlebars');
5 | const Util = require('./util');
6 |
7 | const DEFAULT_PARTITION = 'Common';
8 | const DATA_GROUP = '____bigip_blue_green';
9 | const BASE_DATA_GROUP_URI = '/mgmt/tm/ltm/data-group/internal';
10 | const DATA_GROUP_URI = `${BASE_DATA_GROUP_URI}/~${DEFAULT_PARTITION}~${DATA_GROUP}`;
11 | const SHIM_IRULE_NAME = '_bigip_blue_green';
12 | const SHIM_IRULE_FULLPATH = `/${DEFAULT_PARTITION}/${SHIM_IRULE_NAME}`;
13 | const COOKIE_PREFIX = 'bg';
14 | const IRULE_FILE = './irule-template.tcl';
15 |
16 | class ApiClient {
17 | constructor () {
18 | this.util = new Util('ApiClient', false);
19 | }
20 |
21 | getAllBigIpConfigData (originalRestOp, workerContext) {
22 | const getVsPromise = this.getVirtualServers(originalRestOp, workerContext);
23 | const getPoolsPromise = this.getPools(originalRestOp, workerContext);
24 | return Promise.all([getVsPromise, getPoolsPromise])
25 | .then((values) => {
26 | return { virtualServers: values[0], pools: values[1] };
27 | })
28 | .catch((err) => {
29 | this.util.logError(`getAllBigIpConfigData(): ${err}`);
30 | throw err;
31 | });
32 | }
33 |
34 | /** partitions from the big-ip */
35 | getPartitions (originalRestOp, workerContext) {
36 | const uri = workerContext.restHelper.makeRestjavadUri('/mgmt/tm/auth/partition', '$select=fullPath');
37 | return workerContext.restRequestSender.sendGet(this.getRestOperationInstance(originalRestOp, workerContext, uri))
38 | .then((response) => {
39 | const body = response.getBody();
40 | const items = body.items || [];
41 | return items.map(v => v.fullPath);
42 | })
43 | .catch((err) => {
44 | this.util.logError(`getPartitions(): ${err}`);
45 | throw err;
46 | });
47 | }
48 |
49 | /** GET virtual servers from the big-ip */
50 | getVirtualServers (originalRestOp, workerContext) {
51 | const uri = workerContext.restHelper.makeRestjavadUri('/mgmt/tm/ltm/virtual', 'expandSubcollections=true&$select=name,fullPath,profilesReference/items/nameReference/link');
52 | return workerContext.restRequestSender.sendGet(this.getRestOperationInstance(originalRestOp, workerContext, uri))
53 | .then((response) => {
54 | const body = response.getBody();
55 | const items = body.items || [];
56 | return items.map(v => { return { name: v.name, fullPath: v.fullPath, hasHttpProfile: this.virtualServerHasHttpProfile(v) }; });
57 | })
58 | .catch((err) => {
59 | this.util.logError(`getVirtualServers(): ${err}`);
60 | throw err;
61 | });
62 | }
63 |
64 | /** GET virtual server by full path from the big-ip */
65 | getVirtualServer (originalRestOp, workerContext, virtualServer) {
66 | const vsNamePath = this.convertPathForQuery(virtualServer);
67 | const uri = workerContext.restHelper.makeRestjavadUri(`/mgmt/tm/ltm/virtual/${vsNamePath}`, 'expandSubcollections=true&$select=name,fullPath,profilesReference/items/nameReference/link');
68 | return workerContext.restRequestSender.sendGet(this.getRestOperationInstance(originalRestOp, workerContext, uri))
69 | .then((response) => {
70 | const body = response.getBody();
71 | return { name: body.name, fullPath: body.fullPath, hasHttpProfile: this.virtualServerHasHttpProfile(body) };
72 | })
73 | .catch((err) => {
74 | const errorStatusCode = err.getResponseOperation().getStatusCode();
75 | // virtual server does not exist
76 | if (errorStatusCode === 404) {
77 | return {};
78 | }
79 | this.util.logError(`getVirtualServer(): ${err}`);
80 | throw err;
81 | });
82 | }
83 |
84 | /** GET pools from the big-ip */
85 | getPools (originalRestOp, workerContext) {
86 | const uri = workerContext.restHelper.makeRestjavadUri('/mgmt/tm/ltm/pool', '$select=name,fullPath');
87 | return workerContext.restRequestSender.sendGet(this.getRestOperationInstance(originalRestOp, workerContext, uri))
88 | .then((response) => {
89 | const body = response.getBody();
90 | const items = body.items || [];
91 | return items.map(v => { return { name: v.name, fullPath: v.fullPath }; });
92 | })
93 | .catch((err) => {
94 | this.util.logError(`getPools(): ${err}`);
95 | throw err;
96 | });
97 | }
98 |
99 | /** GET pool by full path from the big-ip */
100 | getPool (originalRestOp, workerContext, poolFullPath) {
101 | const poolNamePath = this.convertPathForQuery(poolFullPath);
102 | const uri = workerContext.restHelper.makeRestjavadUri(`/mgmt/tm/ltm/pool/${poolNamePath}`, '$select=name,fullPath');
103 | return workerContext.restRequestSender.sendGet(this.getRestOperationInstance(originalRestOp, workerContext, uri))
104 | .then((response) => {
105 | const body = response.getBody();
106 | return { name: body.name, fullPath: body.fullPath };
107 | })
108 | .catch((err) => {
109 | const errorStatusCode = err.getResponseOperation().getStatusCode();
110 | // pool does not exist
111 | if (errorStatusCode === 404) {
112 | return {};
113 | }
114 | this.util.logError(`getPool(): ${err}`);
115 | throw err;
116 | });
117 | }
118 |
119 | // *********************** START BUILDERS ***************************************
120 |
121 | /** build blue-green objects on the big-ip */
122 | buildBlueGreenObjects (originalRestOp, workerContext, declaration) {
123 | this.util.logDebug(`buildBlueGreenObjects(): Declaration: ${workerContext.restHelper.jsonPrinter(declaration)}`);
124 | return this.getBlueGreenDeclaration(originalRestOp, workerContext, declaration.name)
125 | .then((originalDeclaration) => {
126 | // if the virtual server is changing for this declaration, unshim the iRule from the previous virtual server
127 | if (!this.util.isEmptyObject(originalDeclaration) && originalDeclaration.virtualServer.toLowerCase() !== declaration.virtualServer.toLowerCase()) {
128 | return this.unShimIRule(originalRestOp, workerContext, originalDeclaration.virtualServer);
129 | }
130 | })
131 | .then(() => this.setBlueGreenDeclaration(originalRestOp, workerContext, declaration))
132 | .then(() => this.iRuleIsShimmed(originalRestOp, workerContext, declaration.virtualServer))
133 | .then((shimmed) => {
134 | if (!shimmed) {
135 | // check if the irule is present, and plug it in!
136 | this.util.logDebug(`buildBlueGreenObjects(): Ready to shim`);
137 | return this.shimIRule(originalRestOp, workerContext, declaration.virtualServer);
138 | }
139 | })
140 | .catch((err) => {
141 | this.util.logError(`buildBlueGreenObjects(): ${err}`);
142 | throw err;
143 | });
144 | }
145 |
146 | /** GET all bluegreen declarations from datagroups from the big-ip */
147 | getAllBlueGreenDeclarations (originalRestOp, workerContext) {
148 | const uri = workerContext.restHelper.makeRestjavadUri(DATA_GROUP_URI);
149 | this.util.logDebug(`getAllBlueGreenDeclarations(): uri ${workerContext.restHelper.jsonPrinter(uri)}`);
150 | return workerContext.restRequestSender.sendGet(this.getRestOperationInstance(originalRestOp, workerContext, uri))
151 | .then((response) => {
152 | this.util.logDebug(`getAllBlueGreenDeclarations(): GET data returned: ${workerContext.restHelper.jsonPrinter(response)}`);
153 | const records = response.body.records || [];
154 | const recordObjects = records.map(record => {
155 | return this.buildDeclarationFromDGRecord(record);
156 | });
157 | this.util.logDebug(`getAllBlueGreenDeclarations(): result: ${workerContext.restHelper.jsonPrinter(recordObjects)}`);
158 | return recordObjects;
159 | })
160 | .catch((err) => {
161 | const errorStatusCode = err.getResponseOperation().getStatusCode();
162 | // datagroup does not yet exist until declarations are set
163 | if (errorStatusCode === 404) {
164 | return [];
165 | }
166 | this.util.logError(`getAllBlueGreenDeclarations(): ${err}`);
167 | throw err;
168 | });
169 | }
170 |
171 | /** GET specific bluegreen declaration from datagroups from the big-ip */
172 | getBlueGreenDeclaration (originalRestOp, workerContext, declarationName) {
173 | return this.getAllBlueGreenDeclarations(originalRestOp, workerContext)
174 | .then((declarations) => {
175 | return declarations.find(declaration => declaration.name === declarationName) || {};
176 | })
177 | .catch((err) => {
178 | this.util.logError(`getBlueGreenDeclaration(): ${err}`);
179 | throw err;
180 | });
181 | }
182 |
183 | /** Checks to see if a declaration by another name already exists for a virtual server on the big-ip */
184 | isDeclarationConflicting (originalRestOp, workerContext, declarationToCheck) {
185 | return this.getAllBlueGreenDeclarations(originalRestOp, workerContext)
186 | .then((declarations) => {
187 | const conflictingDeclaration = declarations.find(declaration =>
188 | declaration.name.toLowerCase() !== declarationToCheck.name.toLowerCase() &&
189 | declaration.virtualServer.toLowerCase() === declarationToCheck.virtualServer.toLowerCase());
190 | return { conflict: conflictingDeclaration !== undefined, reference: conflictingDeclaration };
191 | })
192 | .catch((err) => {
193 | this.util.logError(`isDeclarationConflicting(): ${err}`);
194 | throw err;
195 | });
196 | }
197 |
198 | /** check if bluegreen declaration exists on big-ip */
199 | blueGreenDeclarationExists (originalRestOp, workerContext, declarationName) {
200 | return this.getBlueGreenDeclaration(originalRestOp, workerContext, declarationName)
201 | .then((declaration) => {
202 | this.util.logDebug(`blueGreenDeclarationExists(): GET data returned: ${workerContext.restHelper.jsonPrinter(declaration)}`);
203 | return !this.util.isEmptyObject(declaration);
204 | })
205 | .catch((err) => {
206 | this.util.logError(`blueGreenDeclarationExists(): ${err}`);
207 | throw err;
208 | });
209 | }
210 |
211 | /** Save declaration in a datagroup with a PATCH. If the datagroup doesn't exist create it first with a POST */
212 | setBlueGreenDeclaration (originalRestOp, workerContext, declaration) {
213 | const patchUri = workerContext.restHelper.makeRestjavadUri(`${DATA_GROUP_URI}`);
214 | this.util.logDebug(`setBlueGreenDeclaration(): uri ${workerContext.restHelper.jsonPrinter(patchUri)}`);
215 | return this.ensureDataGroupExists(originalRestOp, workerContext)
216 | .then(() => this.getAllBlueGreenDeclarations(originalRestOp, workerContext))
217 | .then((records) => {
218 | // if a declaration (by name) already exists, always replace it
219 | const newRecordsArray = records.filter(f => f.name !== declaration.name);
220 | newRecordsArray.push(declaration);
221 | this.util.logDebug(`setBlueGreenDeclaration(): new records array ${workerContext.restHelper.jsonPrinter(newRecordsArray)}`);
222 |
223 | return workerContext.restRequestSender.sendPatch(this.getRestOperationInstance(originalRestOp, workerContext, patchUri, this.buildDataGroupBody(newRecordsArray)))
224 | .then((resp) => {
225 | this.util.logDebug(`setBlueGreenDeclaration(): PATCH response ${workerContext.restHelper.jsonPrinter(resp.body)}`);
226 | })
227 | .catch((err) => {
228 | this.util.logError(`setBlueGreenDeclaration() PATCH: ${err}`);
229 | throw err;
230 | });
231 | })
232 | .catch((err) => {
233 | this.util.logError(`setBlueGreenDeclaration(): ${err}`);
234 | throw err;
235 | });
236 | }
237 |
238 | /** DELETE bluegreen declaration in on the big-ip */
239 | deleteBlueGreenDeclaration (originalRestOp, workerContext, declarationName) {
240 | const patchUri = workerContext.restHelper.makeRestjavadUri(`${DATA_GROUP_URI}`);
241 | this.util.logDebug(`deleteBlueGreenDeclaration(): uri ${workerContext.restHelper.jsonPrinter(patchUri)}`);
242 | return this.ensureDataGroupExists(originalRestOp, workerContext)
243 | .then(() => this.getAllBlueGreenDeclarations(originalRestOp, workerContext))
244 | .then((records) => {
245 | // if a declaration (by name) already exists, always replace it
246 | const newRecordsArray = records.filter(f => f.name !== declarationName);
247 | this.util.logDebug(`deleteBlueGreenDeclaration(): new records array ${workerContext.restHelper.jsonPrinter(newRecordsArray)}`);
248 |
249 | return workerContext.restRequestSender.sendPatch(this.getRestOperationInstance(originalRestOp, workerContext, patchUri, this.buildDataGroupBody(newRecordsArray)))
250 | .then((resp) => {
251 | this.util.logDebug(`deleteBlueGreenDeclaration(): PATCH response ${workerContext.restHelper.jsonPrinter(resp.body)}`);
252 | })
253 | .catch((err) => {
254 | this.util.logError(`deleteBlueGreenDeclaration() PATCH: ${err}`);
255 | throw err;
256 | });
257 | })
258 | .catch((err) => {
259 | this.util.logError(`deleteBlueGreenDeclaration(): ${err}`);
260 | throw err;
261 | });
262 | }
263 |
264 | /** GET to see if the declaration datagroup exists on the big-ip and create it if not */
265 | ensureDataGroupExists (originalRestOp, workerContext) {
266 | const uri = workerContext.restHelper.makeRestjavadUri(DATA_GROUP_URI);
267 | return workerContext.restRequestSender.sendGet(this.getRestOperationInstance(originalRestOp, workerContext, uri))
268 | .then(() => true)
269 | .catch((err) => {
270 | const errorStatusCode = err.getResponseOperation().getStatusCode();
271 | if (errorStatusCode === 404) {
272 | return this.createDataGroup(originalRestOp, workerContext);
273 | }
274 | this.util.logError(`ensureDataGroupExists(): ${err}`);
275 | throw err;
276 | });
277 | }
278 |
279 | /** Create the declaration datagroup */
280 | createDataGroup (originalRestOp, workerContext) {
281 | const uri = workerContext.restHelper.makeRestjavadUri(BASE_DATA_GROUP_URI);
282 | this.util.logDebug(`createDataGroup(): at start`);
283 | return workerContext.restRequestSender.sendPost(this.getRestOperationInstance(originalRestOp, workerContext, uri, this.buildDataGroupBody()))
284 | .then((resp) => {
285 | this.util.logDebug(`createDataGroup(): POST response ${workerContext.restHelper.jsonPrinter(resp.body)}`);
286 | return resp.body;
287 | })
288 | .catch((err) => {
289 | this.util.logError(`createDataGroup() POST: ${err}`);
290 | throw err;
291 | });
292 | }
293 |
294 | createShimIRule (originalRestOp, workerContext) {
295 | const uri = workerContext.restHelper.makeRestjavadUri('/mgmt/tm/ltm/rule/');
296 | this.util.logDebug(`createShimIRule(): at start`);
297 | return this.buildIRuleBody(SHIM_IRULE_FULLPATH)
298 | .then((ruleBody) => workerContext.restRequestSender.sendPost(this.getRestOperationInstance(originalRestOp, workerContext, uri, ruleBody)))
299 | .then((resp) => {
300 | this.util.logDebug(`createShimIRule(): POST response ${workerContext.restHelper.jsonPrinter(resp.body)}`);
301 | return resp.body;
302 | })
303 | .catch((err) => {
304 | this.util.logError(`createShimIRule() POST: ${err}`);
305 | throw err;
306 | });
307 | }
308 |
309 | /** GET to see if the shim irule exists on the big-ip */
310 | shimIRuleExists (originalRestOp, workerContext) {
311 | const uri = workerContext.restHelper.makeRestjavadUri(`/mgmt/tm/ltm/rule/${this.convertPathForQuery(SHIM_IRULE_FULLPATH)}`, '$select=fullPath');
312 | return workerContext.restRequestSender.sendGet(this.getRestOperationInstance(originalRestOp, workerContext, uri))
313 | .then(() => true)
314 | .catch((err) => {
315 | const errorStatusCode = err.getResponseOperation().getStatusCode();
316 | if (errorStatusCode === 404) {
317 | return false;
318 | }
319 | this.util.logError(`shimIRuleExists(): ${err}`);
320 | throw err;
321 | });
322 | }
323 |
324 | shimIRule (originalRestOp, workerContext, virtualServer) {
325 | // Check to make sure the shim irule exists first
326 | return this.shimIRuleExists(originalRestOp, workerContext)
327 | .then((exists) => {
328 | this.util.logDebug(`shimIRule(): in first then() ${exists}`);
329 | if (!exists) {
330 | return this.createShimIRule(originalRestOp, workerContext);
331 | }
332 | })
333 | .then(() => {
334 | this.util.logDebug(`shimIRule(): in second then() vsfullpath: ${workerContext.restHelper.jsonPrinter(virtualServer)}`);
335 | return this.getIRulesByVirtualServer(originalRestOp, workerContext, virtualServer);
336 | })
337 | .then((rules) => {
338 | this.util.logDebug(`shimIRule(): in third then()`);
339 | let existingIRules = rules || [];
340 | this.util.logDebug(`shimIRule(): getIRulesByVirtualServer response ${workerContext.restHelper.jsonPrinter(existingIRules)}`);
341 | if (existingIRules.indexOf(SHIM_IRULE_FULLPATH) === -1) {
342 | existingIRules.push(SHIM_IRULE_FULLPATH);
343 | this.util.logDebug(`shimIRule(): after irule push ${workerContext.restHelper.jsonPrinter(existingIRules)}`);
344 | return this.setIRulesByVirtualServer(originalRestOp, workerContext, virtualServer, existingIRules);
345 | }
346 | return existingIRules;
347 | })
348 | .catch((err) => {
349 | this.util.logError(`shimIRule(): ${err}`);
350 | throw err;
351 | });
352 | }
353 |
354 | iRuleIsShimmed (originalRestOp, workerContext, virtualServer) {
355 | // Check to make sure the shim irule exists first
356 | return this.getIRulesByVirtualServer(originalRestOp, workerContext, virtualServer)
357 | .then((rules) => {
358 | let existingIRules = rules || [];
359 | this.util.logDebug(`iRuleIsShimmed(): getIRulesByVirtualServer response ${workerContext.restHelper.jsonPrinter(existingIRules)}`);
360 | return existingIRules.indexOf(SHIM_IRULE_FULLPATH) >= 0;
361 | })
362 | .catch((err) => {
363 | this.util.logError(`iRuleIsShimmed(): ${err}`);
364 | throw err;
365 | });
366 | }
367 |
368 | /** GET irules bound to a virtual server from the big-ip */
369 | getIRulesByVirtualServer (originalRestOp, workerContext, virtualServer) {
370 | const uri = workerContext.restHelper.makeRestjavadUri(`/mgmt/tm/ltm/virtual/${this.convertPathForQuery(virtualServer)}`, '$select=rules');
371 | this.util.logDebug(`getIRulesByVirtualServer(): uri ${workerContext.restHelper.jsonPrinter(uri)}`);
372 | return workerContext.restRequestSender.sendGet(this.getRestOperationInstance(originalRestOp, workerContext, uri))
373 | .then((data) => data.body['rules'])
374 | .catch((err) => {
375 | this.util.logError(`getIRulesByVirtualServer(): ${err}`);
376 | throw err;
377 | });
378 | }
379 |
380 | /** PATCH irules bound to a virtual server from the big-ip */
381 | setIRulesByVirtualServer (originalRestOp, workerContext, virtualServer, iRules) {
382 | const uri = workerContext.restHelper.makeRestjavadUri(`/mgmt/tm/ltm/virtual/${this.convertPathForQuery(virtualServer)}`);
383 | const rules = { rules: iRules };
384 | this.util.logDebug(`setIRulesByVirtualServer(): uri ${workerContext.restHelper.jsonPrinter(uri)} rules ${workerContext.restHelper.jsonPrinter(rules)}`);
385 | return workerContext.restRequestSender.sendPatch(this.getRestOperationInstance(originalRestOp, workerContext, uri, rules))
386 | .then((data) => {
387 | this.util.logDebug(`setIRulesByVirtualServer(): PATCH response ${workerContext.restHelper.jsonPrinter(data.body)}`);
388 | return data.body['rules'];
389 | })
390 | .catch((err) => {
391 | this.util.logError(`setIRulesByVirtualServer(): ${err}`);
392 | throw err;
393 | });
394 | }
395 |
396 | unShimIRuleAndDeleteDeclaration (originalRestOp, workerContext, declarationName) {
397 | return this.getBlueGreenDeclaration(originalRestOp, workerContext, declarationName)
398 | .then((declaration) => {
399 | const deleteBlueGreenDeclarationPromise = this.deleteBlueGreenDeclaration(originalRestOp, workerContext, declaration.name);
400 | const unShimIRulePromise = this.unShimIRule(originalRestOp, workerContext, declaration.virtualServer);
401 | return Promise.all([deleteBlueGreenDeclarationPromise, unShimIRulePromise]);
402 | })
403 | .catch((err) => {
404 | this.util.logError(`unShimIRuleAndDeleteDeclaration(): ${err}`);
405 | throw err;
406 | });
407 | }
408 |
409 | /** DELETE datagroup by partition from the big-ip */
410 | deleteDataGroup (originalRestOp, workerContext) {
411 | const uri = workerContext.restHelper.makeRestjavadUri(DATA_GROUP_URI);
412 | return workerContext.restRequestSender.sendDelete(this.getRestOperationInstance(originalRestOp, workerContext, uri));
413 | }
414 |
415 | unShimIRule (originalRestOp, workerContext, virtualServer) {
416 | this.util.logDebug(`unShimIRule(): virtualServer ${virtualServer}`);
417 | return this.getIRulesByVirtualServer(originalRestOp, workerContext, virtualServer)
418 | .then((data) => {
419 | let iRules = data || [];
420 | if (iRules.indexOf(SHIM_IRULE_FULLPATH) !== -1) {
421 | iRules = iRules.filter(v => v !== SHIM_IRULE_FULLPATH);
422 | return this.setIRulesByVirtualServer(originalRestOp, workerContext, virtualServer, iRules);
423 | }
424 | return iRules;
425 | })
426 | .catch((err) => {
427 | this.util.logError(`unShimIRule(): ${err}`);
428 | throw err;
429 | });
430 | }
431 |
432 | buildIRuleBody (shimIRuleFullPath) {
433 | return new Promise((resolve, reject) => {
434 | fs.readFile(path.join(__dirname, IRULE_FILE), (err, data) => {
435 | // if has error reject, otherwise resolve
436 | if (err) reject(err);
437 | const template = handlebars.compile(data.toString());
438 | const outputString = template({ version: this.util.getApiVersion(), cookiePrefix: COOKIE_PREFIX, dataGroup: DATA_GROUP });
439 | const iRule = {
440 | 'kind': 'tm:ltm:rule:rulestate',
441 | 'name': SHIM_IRULE_NAME,
442 | 'fullPath': shimIRuleFullPath,
443 | 'apiAnonymous': outputString
444 | };
445 | return resolve(iRule);
446 | });
447 | });
448 | }
449 |
450 | buildDataGroupBody (records) {
451 | const body = {
452 | 'name': DATA_GROUP,
453 | 'partition': DEFAULT_PARTITION
454 | };
455 | if (records) {
456 | body['records'] = records.map(record => this.buildDGRecordFromDeclaration(record));
457 | } else {
458 | body['type'] = 'string';
459 | }
460 | return body;
461 | }
462 |
463 | buildDGRecordFromDeclaration (declaration) {
464 | return {
465 | 'name': declaration.name,
466 | 'data': `${declaration.virtualServer},${declaration.distribution},${declaration.bluePool},${declaration.greenPool}`
467 | };
468 | }
469 |
470 | buildDeclarationFromDGRecord (record) {
471 | const dArray = record.data.split(',');
472 | return {
473 | name: record.name,
474 | virtualServer: dArray[0],
475 | distribution: Number(dArray[1]),
476 | bluePool: dArray[2],
477 | greenPool: dArray[3]
478 | };
479 | }
480 |
481 | convertPathForQuery (path) {
482 | return path.replace(/\//g, '~');
483 | }
484 |
485 | getRestOperationInstance (originalRestOp, workerContext, uri, body) {
486 | const restOp = workerContext.restOperationFactory.createRestOperationInstance()
487 | .setUri(uri)
488 | .setIsSetBasicAuthHeader(true)
489 | .setBasicAuthorization(originalRestOp.getBasicAuthorization());
490 | if (body !== undefined) {
491 | restOp.setBody(body);
492 | }
493 | return restOp;
494 | }
495 |
496 | virtualServerHasHttpProfile (virtualServer) {
497 | const profilesArray = virtualServer.profilesReference.items || [];
498 | this.util.logDebug(`virtualServerHasHttpProfile(): virtualServer ${JSON.stringify(virtualServer)}`);
499 | // eslint-disable-next-line no-useless-escape
500 | const pattern = new RegExp('\/ltm\/profile\/http\/');
501 | return profilesArray.filter(p => this.util.safeAccess(() => p.nameReference.link, false) && pattern.test(p.nameReference.link.toLowerCase())).length > 0;
502 | }
503 | }
504 |
505 | module.exports = ApiClient;
506 |
--------------------------------------------------------------------------------
/api/nodejs/bigIpConfigRestWorker.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | const ApiClient = require('./apiClient');
3 | const Util = require('./util');
4 |
5 | /**
6 | * @class BigIpConfigRestWorker
7 | * @mixes RestWorker
8 | *
9 | * @description A simple worker that outlines functions that
10 | * can be defined and when and how they are called
11 | *
12 | * Called when the worker is loaded from disk and first
13 | * instantiated by the @LoaderWorker
14 | * @constructor
15 | */
16 | class BigIpConfigRestWorker {
17 | constructor () {
18 | this.apiClient = new ApiClient();
19 | this.util = new Util('BigIpConfigRestWorker', false);
20 | this.WORKER_URI_PATH = 'shared/blue-green/bigip-config';
21 | this.isPublic = true;
22 | }
23 |
24 | /*****************
25 | * http handlers *
26 | *****************/
27 |
28 | /**
29 | * optional
30 | * handle onGet HTTP request
31 | * @param {Object} restOperation
32 | */
33 | onGet (restOperation) {
34 | const workerContext = this;
35 | this.apiClient.getAllBigIpConfigData(restOperation, workerContext)
36 | .then((items) => {
37 | this.completeSuccess(restOperation, items);
38 | })
39 | .catch((err) => {
40 | this.completeError(restOperation, err);
41 | });
42 | }
43 |
44 | completeSuccess (restOperation, output) {
45 | restOperation.setStatusCode(200);
46 | restOperation.setBody(output);
47 | restOperation.complete();
48 | }
49 |
50 | completeError (restOperation, error) {
51 | const code = error.code || 500;
52 | this.util.logError(this.restHelper.jsonPrinter(error));
53 | restOperation.setStatusCode(code);
54 | restOperation.setBody(error.message);
55 | restOperation.complete();
56 | }
57 | }
58 |
59 | module.exports = BigIpConfigRestWorker;
60 |
--------------------------------------------------------------------------------
/api/nodejs/blueGreenConfigRestWorker.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | const ApiClient = require('./apiClient');
3 | const Util = require('./util');
4 |
5 | /**
6 | * @class BlueGreenConfigRestWorker
7 | * @mixes RestWorker
8 | *
9 | * @description A simple worker that outlines functions that
10 | * can be defined and when and how they are called
11 | *
12 | * Called when the worker is loaded from disk and first
13 | * instantiated by the @LoaderWorker
14 | * @constructor
15 | */
16 | class BlueGreenConfigRestWorker {
17 | constructor () {
18 | this.apiClient = new ApiClient();
19 | this.util = new Util('BlueGreenConfigRestWorker', false);
20 | this.WORKER_URI_PATH = 'shared/blue-green/config';
21 | this.isPublic = true;
22 | this.isPassThrough = true;
23 | }
24 |
25 | /*****************
26 | * http handlers *
27 | *****************/
28 |
29 | /**
30 | * optional
31 | * handle onGet HTTP request
32 | * @param {Object} restOperation
33 | */
34 | onGet (restOperation) {
35 | const workerContext = this;
36 | const declarationName = restOperation.getUri().pathname.split('/')[4];
37 | if (!declarationName) {
38 | this.apiClient.getAllBlueGreenDeclarations(restOperation, workerContext)
39 | .then((declarations) => {
40 | this.completeSuccess(restOperation, declarations);
41 | })
42 | .catch((err) => {
43 | this.completeError(restOperation, err);
44 | });
45 | } else {
46 | this.apiClient.getBlueGreenDeclaration(restOperation, workerContext, declarationName)
47 | .then((declaration) => {
48 | if (!this.util.isEmptyObject(declaration)) {
49 | this.completeSuccess(restOperation, declaration);
50 | } else {
51 | const err = new Error(`declaration '${declarationName}' does not exist`);
52 | err.code = 404;
53 | this.completeError(restOperation, err);
54 | }
55 | })
56 | .catch((err) => {
57 | this.completeError(restOperation, err);
58 | });
59 | }
60 | }
61 |
62 | completeSuccess (restOperation, output) {
63 | restOperation.setStatusCode(200);
64 | restOperation.setBody(output);
65 | restOperation.complete();
66 | }
67 |
68 | completeError (restOperation, error) {
69 | const code = error.code || 500;
70 | this.util.logError(this.restHelper.jsonPrinter(error));
71 | restOperation.setStatusCode(code);
72 | restOperation.setBody(error.message);
73 | restOperation.complete();
74 | }
75 | }
76 |
77 | module.exports = BlueGreenConfigRestWorker;
78 |
--------------------------------------------------------------------------------
/api/nodejs/declarationRestWorker.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | const ApiClient = require('./apiClient');
3 | const Util = require('./util');
4 |
5 | /**
6 | * @class DeclarationRestWorker
7 | * @mixes RestWorker
8 | *
9 | * @description A simple worker that outlines functions that
10 | * can be defined and when and how they are called
11 | *
12 | * Called when the worker is loaded from disk and first
13 | * instantiated by the @LoaderWorker
14 | * @constructor
15 | */
16 | class DeclarationRestWorker {
17 | constructor () {
18 | this.apiClient = new ApiClient();
19 | this.util = new Util('DeclarationRestWorker', false);
20 | this.WORKER_URI_PATH = 'shared/blue-green/declare';
21 | this.isPublic = true;
22 | this.isPassThrough = true;
23 | }
24 |
25 | /**
26 | * handle onPost HTTP request
27 | * @param {Object} restOperation
28 | */
29 | onPost (restOperation) {
30 | const workerContext = this;
31 | this.util.logDebug('blue-green declaration POST request');
32 |
33 | let declaration = restOperation.getBody();
34 |
35 | this.util.validateDeclaration(declaration)
36 | .then((validatedDeclaration) => {
37 | this.util.logInfo('Schema valid blue-green declaration');
38 | declaration = validatedDeclaration;
39 | })
40 | .then(() => this.apiClient.getVirtualServer(restOperation, workerContext, declaration.virtualServer))
41 | .then((vs) => {
42 | if (this.util.isEmptyObject(vs)) {
43 | throw new Error('Virtual Server does not exist.');
44 | } else if (!vs.hasHttpProfile) {
45 | throw new Error('Virtual Server has no Http Profile.');
46 | }
47 | })
48 | .then(() => this.apiClient.getPools(restOperation, workerContext))
49 | .then((pools) => {
50 | if (!pools.find(p => p.fullPath === declaration.bluePool)) throw new Error(`Blue pool '${declaration.bluePool}' does not exist.`);
51 | if (!pools.find(p => p.fullPath === declaration.greenPool)) throw new Error(`Green pool '${declaration.greenPool}' does not exist.`);
52 | })
53 | .then(() => this.apiClient.isDeclarationConflicting(restOperation, workerContext, declaration))
54 | .then((result) => {
55 | if (result.conflict) {
56 | throw new Error(`Virtual Server in declaration '${declaration.name}' conflicts with existing declaration '${result.reference.name}'`);
57 | }
58 | })
59 | .then(() => {
60 | this.util.logInfo(`No existing declaration conflicts with provided blue-green declaration`);
61 | return this.apiClient.buildBlueGreenObjects(restOperation, workerContext, declaration);
62 | })
63 | .then(() => {
64 | restOperation.setBody(declaration);
65 | this.completeRestOperation(restOperation);
66 | })
67 | .catch((err) => {
68 | err.code = 422;
69 | this.util.logError(`declarationRestWorker onPost(): ${err}`);
70 | this.completeError(restOperation, err);
71 | });
72 | }
73 |
74 | /**
75 | * Handle HTTP DELETE method
76 | * @param {object} restOperation
77 | * @returns {void}
78 | */
79 | onDelete (restOperation) {
80 | const workerContext = this;
81 | const objectId = restOperation.getUri().pathname.split('/')[4];
82 |
83 | this.util.logDebug(`blue-green declaration DELETE request ${objectId}`);
84 |
85 | this.apiClient.blueGreenDeclarationExists(restOperation, workerContext, objectId)
86 | .then((exists) => {
87 | if (exists) {
88 | return this.apiClient.unShimIRuleAndDeleteDeclaration(restOperation, workerContext, objectId);
89 | } else {
90 | const err = new Error(`declaration '${objectId}' does not exist`);
91 | err.code = 404;
92 | throw err;
93 | }
94 | })
95 | .then(() => {
96 | this.completeSuccess(restOperation, `{"message": "declaration '${objectId}' successfully deleted"}`);
97 | })
98 | .catch((err) => {
99 | this.completeError(restOperation, err);
100 | });
101 | }
102 |
103 | /**
104 | * Create a handler for requests to/example
105 | * @return {Object} example of the object model for this worker
106 | */
107 | getExampleState () {
108 | const example = {
109 | 'name': 'Sample1',
110 | 'virtualServer': '/Common/MyVirtualServer',
111 | 'distribution': 0.8,
112 | 'bluePool': '/Common/blue_pool',
113 | 'greenPool': '/Common/green_pool'
114 | };
115 | return example;
116 | }
117 |
118 | completeSuccess (restOperation, output) {
119 | restOperation.setStatusCode(200);
120 | restOperation.setBody(output);
121 | restOperation.complete();
122 | }
123 |
124 | completeError (restOperation, error) {
125 | const code = error.code || 500;
126 | this.util.logError(this.restHelper.jsonPrinter(error));
127 | restOperation.setStatusCode(code);
128 | restOperation.setBody(error.message);
129 | restOperation.complete();
130 | }
131 | }
132 |
133 | module.exports = DeclarationRestWorker;
134 |
--------------------------------------------------------------------------------
/api/nodejs/irule-template.tcl:
--------------------------------------------------------------------------------
1 | # BlueGreen v{{version}}
2 |
3 | proc get_datagroup_value {dg_name vs_full_path} {
4 | set dg [class get $dg_name]
5 | foreach x $dg {
6 | if { $x starts_with $vs_full_path} {
7 | return $x
8 | break
9 | }
10 | }
11 | }
12 |
13 | proc get_cookie_name {vs_full_path} {
14 | return "{{cookiePrefix}}[string map "/ _" $vs_full_path]"
15 | }
16 |
17 | proc validate_pool {requested_pool blue_pool green_pool} {
18 | set valid_pools [list $blue_pool $green_pool]
19 | if {[lsearch $valid_pools $requested_pool] != -1} {
20 | return $requested_pool
21 | } else {
22 | # if requested pool isn't either blue or green, return blue.
23 | return [lindex $valid_pools 0]
24 | }
25 | }
26 |
27 | proc debug_log {flag message} {
28 | if { $flag } { log local0. $message }
29 | }
30 |
31 | when CLIENT_ACCEPTED {
32 | set DEBUG 0
33 | set cookie_expiration_seconds 1200
34 | }
35 |
36 | when HTTP_REQUEST {
37 | # Use this to set the cookie name as well as to look up the distribution and pool name settings from the datagroup
38 | set traffic_dist_rule [call get_datagroup_value "{{dataGroup}}" [virtual name]]
39 | set fields [split $traffic_dist_rule ","]
40 | set vs [lindex $fields 0]
41 | set distribution [lindex $fields 1]
42 | set blue_pool [lindex $fields 2]
43 | set green_pool [lindex $fields 3]
44 | set blue_green_cookie [call get_cookie_name $vs]
45 | set cookie_exists [HTTP::cookie exists $blue_green_cookie]
46 | call debug_log $DEBUG "distribution: $distribution"
47 |
48 | switch -- $distribution {
49 | "0" {
50 | pool $green_pool
51 | call debug_log $DEBUG "defaulting to green pool"
52 | set remove_cookie 1
53 | }
54 |
55 | "1" {
56 | pool $blue_pool
57 | call debug_log $DEBUG "defaulting to blue pool"
58 | set remove_cookie 1
59 | }
60 |
61 | default {
62 | # Check if there is a pool selector cookie in the request
63 | if { $cookie_exists } {
64 | # Make sure that the pool in the cookie is one of either blue or green pools. Prevent the client from using an undesired pool.
65 | set pool_name [call validate_pool [HTTP::cookie $blue_green_cookie] $blue_pool $green_pool]
66 | call debug_log $DEBUG "validated pool: $pool_name"
67 | pool $pool_name
68 | set cookie_value_to_set ""
69 | } else {
70 | # No pool selector cookie, so choose a pool based on the datagroup distribution
71 | set rand [expr { rand() }]
72 | if { $rand < $distribution } {
73 | pool $blue_pool
74 | set cookie_value_to_set $blue_pool
75 | } else {
76 | pool $green_pool
77 | set cookie_value_to_set $green_pool
78 | }
79 | }
80 | }
81 | }
82 | }
83 |
84 | when HTTP_RESPONSE {
85 | # Set a pool selector cookie from the pool that was was selected for this request
86 | if {[info exists cookie_value_to_set] && $cookie_value_to_set ne ""}{
87 | call debug_log $DEBUG "inserting cookie"
88 | HTTP::cookie insert name $blue_green_cookie value $cookie_value_to_set path "/"
89 | HTTP::cookie expires $blue_green_cookie $cookie_expiration_seconds relative
90 | } elseif {$cookie_exists && [info exists remove_cookie] } {
91 | unset -- remove_cookie
92 | # If there is no need to store a selected pool in a cookie, remove any previously stored blue-green cookie for this vs
93 | call debug_log $DEBUG "removing cookie $blue_green_cookie"
94 | HTTP::header insert Set-Cookie "$blue_green_cookie=deleted;expires=Thu, 01 Jan 1970 00:00:00 GMT"
95 | }
96 | }
--------------------------------------------------------------------------------
/api/nodejs/schema.json:
--------------------------------------------------------------------------------
1 | {
2 | "definitions": {},
3 | "$id": "https://github.com/aknot242/bigip-blue-green",
4 | "type": "object",
5 | "title": "The Root Schema",
6 | "required": [
7 | "name",
8 | "virtualServer",
9 | "distribution",
10 | "bluePool",
11 | "greenPool"
12 | ],
13 | "properties": {
14 | "name": {
15 | "$id": "#/properties/name",
16 | "type": "string",
17 | "title": "The Name Schema",
18 | "default": "",
19 | "examples": [
20 | "My_BlueGreen_Config"
21 | ],
22 | "pattern": "^[A-Za-z][0-9A-Za-z_-]{0,47}$"
23 | },
24 | "virtualServer": {
25 | "$id": "#/properties/virtualServer",
26 | "type": "string",
27 | "title": "The Virtual Server Schema",
28 | "default": "",
29 | "examples": [
30 | "/MyPartition/Application_1/serviceMain"
31 | ],
32 | "pattern": "^\\x2f[^\\x00-\\x19\\x22#'*<>?\\x5b-\\x5d\\x7b-\\x7d\\x7f]+$"
33 | },
34 | "distribution": {
35 | "$id": "#/properties/distribution",
36 | "type": "number",
37 | "title": "The Distribution Schema",
38 | "minimum": 0.0,
39 | "maximum": 1.0,
40 | "default": 0.0,
41 | "examples": [
42 | 0.5
43 | ]
44 | },
45 | "bluePool": {
46 | "$id": "#/properties/bluePool",
47 | "type": "string",
48 | "format": "pool-must-be-accessible-to-virtual-server",
49 | "title": "The Blue Pool Schema",
50 | "default": "",
51 | "examples": [
52 | "blue_pool"
53 | ],
54 | "pattern": "^\\x2f[^\\x00-\\x19\\x22#'*<>?\\x5b-\\x5d\\x7b-\\x7d\\x7f]+$"
55 | },
56 | "greenPool": {
57 | "$id": "#/properties/greenPool",
58 | "type": "string",
59 | "format": "pool-must-be-accessible-to-virtual-server",
60 | "title": "The Green Pool Schema",
61 | "default": "",
62 | "examples": [
63 | "green_pool"
64 | ],
65 | "pattern": "^\\x2f[^\\x00-\\x19\\x22#'*<>?\\x5b-\\x5d\\x7b-\\x7d\\x7f]+$"
66 | }
67 | }
68 | }
69 |
--------------------------------------------------------------------------------
/api/nodejs/util.js:
--------------------------------------------------------------------------------
1 | /*
2 | * Util:
3 | * Collection of helper functions for BlueGreen modules.
4 | *
5 | * D. Edgar, January 2019
6 | * http://github.com/aknot242
7 | *
8 | */
9 |
10 | 'use strict';
11 | const BlueGreenSchema = require('./schema.json');
12 | const Ajv = require('ajv');
13 | const F5Logger = require('f5-logger');
14 | const COMMON_PARTITION = 'Common';
15 |
16 | class Util {
17 | constructor (moduleName, debugEnabled) {
18 | this.moduleName = moduleName;
19 | this.debugEnabled = debugEnabled;
20 | this.loggerInstance = F5Logger.getInstance();
21 | }
22 |
23 | /**
24 | * Logging helper used to log info messages
25 | * @param {*} message The info message to log
26 | */
27 | logInfo (message) {
28 | this.loggerInstance.info(this.formatMessage(message));
29 | }
30 |
31 | /**
32 | * Logging helper used to log debug messages
33 | * @param {*} message The debug message to log
34 | */
35 | logDebug (message) {
36 | if (this.debugEnabled === true) {
37 | this.loggerInstance.info(this.formatMessage(message, 'DEBUG'));
38 | }
39 | }
40 |
41 | /**
42 | * Logging helper used to log error messages
43 | * @param {*} message The error message to log
44 | */
45 | logError (message) {
46 | this.loggerInstance.info(this.formatMessage(message, 'ERROR'));
47 | }
48 |
49 | /**
50 | * String formatting helper for log messages
51 | * @param {*} message The message to format
52 | */
53 | formatMessage (message, classifier) {
54 | classifier = typeof classifier !== 'undefined' ? ` - ${classifier}` : '';
55 | return `[${this.moduleName}${classifier}] - ${message}`;
56 | }
57 |
58 | /**
59 | * Safely access object and property values without having to stack up safety checks for undefined values
60 | * @param {*} func A function that encloses the value to check
61 | * @param {*} fallbackValue An optional default value that is returned if any of the values in the object heirarchy are undefined. If this parameter isn't supplied, undefined will be returned instead of a default fallback value.
62 | */
63 | safeAccess (func, fallbackValue) {
64 | try {
65 | var value = func();
66 | return (value === null || value === undefined) ? fallbackValue : value;
67 | } catch (e) {
68 | return fallbackValue;
69 | }
70 | }
71 |
72 | validateDeclaration (input) {
73 | return new Promise((resolve, reject) => {
74 | let message = 'success';
75 | const jsonInput = this.isJson(input);
76 | // Validate the input against the schema
77 | let ajv = new Ajv({ jsonPointers: true, allErrors: false, verbose: true, useDefaults: false });
78 |
79 | this.getSchemaFormats(jsonInput).forEach(format => ajv.addFormat(format.name, format.check));
80 | const validate = ajv.compile(BlueGreenSchema);
81 | const valid = validate(jsonInput);
82 | if (valid === false) {
83 | const error = this.safeAccess(() => validate.errors[0].message, '');
84 | if (error !== '') {
85 | message = this.translateAjvError(validate.errors[0]);
86 | } else {
87 | message = 'Unknown validation error.';
88 | }
89 | reject(new Error(`Schema invalid blue-green declaration: ${message}`));
90 | }
91 | this.logDebug(`validateDeclaration(): ${message}`);
92 | resolve(jsonInput);
93 | });
94 | }
95 |
96 | /**
97 | * Format an Ajv schema validator message depending on category
98 | *
99 | * @param {*} errorDetail
100 | */
101 | translateAjvError (errorDetail) {
102 | switch (errorDetail.keyword) {
103 | case 'enum':
104 | return `${errorDetail.dataPath} ${errorDetail.message}. Specified value: ${errorDetail.data} (allowed value(s) are ${errorDetail.params.allowedValues}`;
105 | case 'required':
106 | return errorDetail.message;
107 | default:
108 | return `${errorDetail.dataPath} ${errorDetail.message}`;
109 | }
110 | }
111 |
112 | /**
113 | * If not an Object, can we parse it?
114 | *
115 | * @param {(object|string)} input
116 | *
117 | * @return {object}
118 | */
119 | isJson (input) {
120 | if (input && typeof input !== 'object') {
121 | try {
122 | input = JSON.parse(input);
123 | } catch (err) {
124 | this.logInfo(`Unable to parse input: ${err}`);
125 | return;
126 | }
127 | }
128 | return input;
129 | }
130 |
131 | isEmptyObject (obj) {
132 | return !Object.keys(obj).length > 0;
133 | }
134 |
135 | getApiVersion () {
136 | try {
137 | const pjson = require('../package.json');
138 | return pjson.version;
139 | } catch (err) {
140 | this.logError(`Unable to determine API package version: ${err}`);
141 | return 'UNKNOWN';
142 | }
143 | }
144 |
145 | getLowerCasePartition (fullPath) {
146 | return fullPath.split('/')[1].toLowerCase();
147 | }
148 |
149 | getSchemaFormats (declaration) {
150 | return [
151 | {
152 | name: 'pool-must-be-accessible-to-virtual-server',
153 | check: poolRef => {
154 | if (declaration.virtualServer === undefined) return false;
155 | const poolPartition = this.getLowerCasePartition(poolRef);
156 | return poolPartition === this.getLowerCasePartition(declaration.virtualServer) || poolPartition === COMMON_PARTITION.toLowerCase();
157 | }
158 | }];
159 | }
160 | }
161 |
162 | module.exports = Util;
163 |
--------------------------------------------------------------------------------
/api/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "bigip-blue-green-api",
3 | "version": "0.9.2",
4 | "description": "API for bigip-blue-green",
5 | "repository": {
6 | "type": "git",
7 | "url": "https://github.com/aknot242/bigip-blue-green.git"
8 | },
9 | "main": "index.js",
10 | "scripts": {
11 | "test": "echo \"Error: no test specified\" && exit 1"
12 | },
13 | "author": "",
14 | "license": "ISC",
15 | "devDependencies": {
16 | "eslint": "^5.16.0",
17 | "eslint-config-standard": "^12.0.0",
18 | "eslint-plugin-import": "^2.16.0",
19 | "eslint-plugin-node": "^8.0.1",
20 | "eslint-plugin-promise": "^4.0.1",
21 | "eslint-plugin-standard": "^4.0.0"
22 | },
23 | "dependencies": {
24 | "ajv": "^6.12.3",
25 | "handlebars": "^4.7.7"
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/api/scripts/refreshBigIp.sh:
--------------------------------------------------------------------------------
1 | USER=""
2 | PASS=""
3 | SERVER=""
4 | # echo $USER $PASS
5 | sshpass -p $PASS scp $2 $USER@$SERVER:/var/config/rest/iapps/bigip-blue-green/nodejs/
6 | ssh $USER@$SERVER "bigstart restart restnoded"
7 |
--------------------------------------------------------------------------------
/build/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM node:10-alpine
2 |
3 | RUN apk add rpm bash
4 |
--------------------------------------------------------------------------------
/build/Dockerfile.asg:
--------------------------------------------------------------------------------
1 | FROM f5devcentral/f5-api-services-gateway:1.0.7 as builder
2 | ARG TARGET
3 | COPY $TARGET /tmp
4 | RUN rpm --nodeps -i /tmp/$(basename $TARGET)
5 | RUN rm /tmp/$(basename $TARGET)
6 |
7 | FROM f5devcentral/f5-api-services-gateway:1.0.7
8 | COPY --from=builder /var/config/rest/iapps/ /var/config/rest/iapps
9 |
--------------------------------------------------------------------------------
/build/bigip-blue-green.spec:
--------------------------------------------------------------------------------
1 | Summary: BIG-IP BlueGreen Deployment iControlLX extension
2 | Name: bigip-blue-green
3 | Version: %{_version}
4 | Release: %{_release}
5 | BuildArch: noarch
6 | Group: Development/Tools
7 | License: Commercial
8 | Packager: F5 Networks
3 |
5 |
6 |
7 | 
{{ title }}
5 |
9 |
--------------------------------------------------------------------------------
/ui/src/app/app.component.spec.ts:
--------------------------------------------------------------------------------
1 | import { TestBed, async } from '@angular/core/testing';
2 | import { RouterTestingModule } from '@angular/router/testing'
3 | import { NgHttpLoaderModule } from 'ng-http-loader';
4 | import { AppComponent } from './app.component';
5 | import { MessagesComponent } from './messages/messages.component';
6 |
7 | describe('AppComponent', () => {
8 | beforeEach(async(() => {
9 | TestBed.configureTestingModule({
10 | declarations: [
11 | AppComponent,
12 | MessagesComponent
13 | ],
14 | imports: [
15 | RouterTestingModule,
16 | NgHttpLoaderModule
17 | ]
18 | }).compileComponents();
19 | }));
20 |
21 | it('should create the app', () => {
22 | const fixture = TestBed.createComponent(AppComponent);
23 | const app = fixture.debugElement.componentInstance;
24 | expect(app).toBeTruthy();
25 | });
26 |
27 | it(`should have as title 'BIG-IP BlueGreen Deployment'`, () => {
28 | const fixture = TestBed.createComponent(AppComponent);
29 | const app = fixture.debugElement.componentInstance;
30 | expect(app.title).toEqual('BIG-IP BlueGreen Deployment');
31 | });
32 |
33 | it('should render title in a h1 tag', () => {
34 | const fixture = TestBed.createComponent(AppComponent);
35 | fixture.detectChanges();
36 | const compiled = fixture.debugElement.nativeElement;
37 | expect(compiled.querySelector('h1').textContent).toContain('BIG-IP BlueGreen Deployment');
38 | });
39 | });
40 |
--------------------------------------------------------------------------------
/ui/src/app/app.component.ts:
--------------------------------------------------------------------------------
1 | import { Component, OnInit } from '@angular/core';
2 |
3 | @Component({
4 | selector: 'app-root',
5 | templateUrl: './app.component.html',
6 | styleUrls: ['./app.component.css']
7 | })
8 | export class AppComponent {
9 | title = 'BIG-IP BlueGreen Deployment';
10 | }
--------------------------------------------------------------------------------
/ui/src/app/app.module.ts:
--------------------------------------------------------------------------------
1 | import { BrowserModule } from '@angular/platform-browser';
2 | import { NgModule } from '@angular/core';
3 | import { FormsModule } from '@angular/forms';
4 | import { AppComponent } from './app.component';
5 | import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
6 | import { MatButtonModule } from '@angular/material/button';
7 | import { MatDialogModule } from '@angular/material/dialog';
8 | import { MatFormFieldModule } from '@angular/material/form-field';
9 | import { MatInputModule } from '@angular/material/input';
10 | import { MatSelectModule } from '@angular/material/select';
11 | import { MatSliderModule } from '@angular/material/slider';
12 | import { MatTableModule } from '@angular/material/table';
13 | import { BigIpService, AuthService } from './bigip/services';
14 | import { HttpClientModule, HTTP_INTERCEPTORS, HttpClient } from '@angular/common/http';
15 | import { NgHttpLoaderModule } from 'ng-http-loader';
16 | import { UniqueDeclarationNameValidator } from './unique-declaration-name.directive';
17 | import { AuthInterceptor } from './http-interceptors/auth-interceptor';
18 | import { AuthDialog } from './dialogs/auth-dialog';
19 | import { DeclarationDetailComponent } from './declaration-detail/declaration-detail.component';
20 | import { DeclarationsComponent } from './declarations/declarations.component';
21 | import { AppRoutingModule } from './app-routing.module';
22 | import { MessagesComponent } from './messages/messages.component';
23 | import { ConfirmDialog } from './dialogs/confirm-dialog';
24 |
25 | @NgModule({
26 | declarations: [
27 | AppComponent,
28 | UniqueDeclarationNameValidator,
29 | AuthDialog,
30 | ConfirmDialog,
31 | DeclarationDetailComponent,
32 | DeclarationsComponent,
33 | MessagesComponent
34 | ],
35 | imports: [
36 | AppRoutingModule,
37 | HttpClientModule,
38 | FormsModule,
39 | BrowserModule,
40 | BrowserAnimationsModule,
41 | MatFormFieldModule,
42 | MatButtonModule,
43 | MatSliderModule,
44 | MatSelectModule,
45 | MatInputModule,
46 | MatDialogModule,
47 | MatTableModule,
48 | NgHttpLoaderModule.forRoot()
49 | ],
50 | providers: [
51 | { provide: HTTP_INTERCEPTORS, useClass: AuthInterceptor, multi: true },
52 | BigIpService,
53 | AuthService,
54 | HttpClient
55 | ],
56 | entryComponents: [AuthDialog, ConfirmDialog],
57 | bootstrap: [AppComponent]
58 | })
59 | export class AppModule { }
60 |
--------------------------------------------------------------------------------
/ui/src/app/bigip/bigip.module.ts:
--------------------------------------------------------------------------------
1 | import { NgModule, ModuleWithProviders } from '@angular/core';
2 | import { BigIpService } from './services';
3 |
4 | @NgModule()
5 | export class BigIpModule {
6 |
7 | static forRoot(): ModuleWithProviders {
8 | return {
9 | ngModule: BigIpModule,
10 | providers: [
11 | BigIpService
12 | ]
13 | }
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/ui/src/app/bigip/models/config-data.ts:
--------------------------------------------------------------------------------
1 | import { ObjectReference } from './object-reference';
2 | import { VirtualServerReference } from './virtual-server-reference';
3 |
4 | export class ConfigData {
5 | virtualServers: VirtualServerReference[];
6 | pools: ObjectReference[];
7 | }
8 |
--------------------------------------------------------------------------------
/ui/src/app/bigip/models/declaration.ts:
--------------------------------------------------------------------------------
1 | export class Declaration {
2 | name: string;
3 | virtualServer: string;
4 | distribution: number;
5 | bluePool: string;
6 | greenPool: string;
7 | }
8 |
--------------------------------------------------------------------------------
/ui/src/app/bigip/models/object-reference.ts:
--------------------------------------------------------------------------------
1 | export class ObjectReference {
2 | name: string;
3 | fullPath: string;
4 | }
5 |
--------------------------------------------------------------------------------
/ui/src/app/bigip/models/virtual-server-reference.ts:
--------------------------------------------------------------------------------
1 | import { ObjectReference } from './object-reference';
2 |
3 | export class VirtualServerReference extends ObjectReference {
4 | hasHttpProfile: boolean;
5 | }
6 |
--------------------------------------------------------------------------------
/ui/src/app/bigip/services/auth.service.ts:
--------------------------------------------------------------------------------
1 | import { HttpClient } from '@angular/common/http';
2 | import { Observable } from 'rxjs';
3 | import { map, tap } from 'rxjs/operators';
4 | import { Injectable } from '@angular/core';
5 |
6 | @Injectable()
7 | export class AuthService {
8 | public currentToken = '';
9 |
10 | constructor(private http: HttpClient) { }
11 |
12 | getAuthToken() {
13 | return this.currentToken;
14 | }
15 |
16 | authenticate(): ObservableDeclarations
2 || Name | 5 |{{element.name}} | 6 |Virtual Server | 10 |{{element.virtualServer}} | 11 |Action | 15 |16 | 17 | 18 | | 19 |
|---|
{{ message }}
2 |
3 |
5 | To use this module, you must first log in to BIG-IP TMUI.
4 |
6 |
7 |
--------------------------------------------------------------------------------
/ui/src/app/dialogs/auth-dialog.ts:
--------------------------------------------------------------------------------
1 | import { Component, Inject } from '@angular/core';
2 | import { MatDialogRef, MAT_DIALOG_DATA } from '@angular/material/dialog';
3 |
4 | @Component({
5 | selector: 'auth-dialog',
6 | templateUrl: 'auth-dialog.html',
7 | })
8 | export class AuthDialog {
9 | message: string;
10 |
11 | constructor(public dialogRef: MatDialogRef{{data.title}}
2 |
3 |
5 | {{data.message}}
4 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/ui/src/app/dialogs/confirm-dialog.ts:
--------------------------------------------------------------------------------
1 | import { Component, Inject } from '@angular/core';
2 | import { MatDialogRef, MAT_DIALOG_DATA } from '@angular/material/dialog';
3 |
4 | export interface ConfirmDialogData {
5 | title: string;
6 | message: string;
7 | }
8 |
9 | @Component({
10 | selector: 'confirm-dialog',
11 | templateUrl: 'confirm-dialog.html',
12 | })
13 | export class ConfirmDialog {
14 | message: string;
15 |
16 | constructor(public dialogRef: MatDialogRef
2 |
6 |
--------------------------------------------------------------------------------
/ui/src/app/messages/messages.component.spec.ts:
--------------------------------------------------------------------------------
1 | import { async, ComponentFixture, TestBed } from '@angular/core/testing';
2 |
3 | import { MessagesComponent } from './messages.component';
4 |
5 | describe('MessagesComponent', () => {
6 | let component: MessagesComponent;
7 | let fixture: ComponentFixtureMessages
3 | 4 | {{message}}
5 |