Merge pull request #1191 from stephenplusplus/spp--1073-forwarding-rules

compute: support Forwarding Rules

Author: callmehiphop

lib/compute/index.js

@@ -49,6 +49,12 @@ var Operation = require('./operation.js');
  */
 var Region = require('./region.js');
 
+/**
+ * @type {module:compute/rule}
+ * @private
+ */
+var Rule = require('./rule.js');
+
 /**
  * @type {module:common/service}
  * @private
@@ -311,6 +317,96 @@ Compute.prototype.createNetwork = function(name, config, callback) {
   });
 };
 
+/**
+ * Create a global forwarding rule.
+ *
+ * @resource [GlobalForwardingRule Resource]{@link https://cloud.google.com/compute/docs/reference/v1/globalForwardingRules#resource}
+ * @resource [GlobalForwardingRules: insert API Documentation]{@link https://cloud.google.com/compute/docs/reference/v1/globalForwardingRules/insert}
+ *
+ * @param {string} name - Name of the rule.
+ * @param {object} config - See a
+ *     [GlobalForwardingRule resource](https://cloud.google.com/compute/docs/reference/v1/globalForwardingRules#resource).
+ * @param {string=} config.ip - The single IP address this forwarding rule will
+ *     match against. All traffic that matches the IP address, protocol, and
+ *     ports of this forwarding rule will be handled by this rule. If specified,
+ *     the IP address must be a static external IP address. To create a new
+ *     ephemeral external IP address for the forwarding rule, leave this field
+ *     empty. (Alias for `config.IPAddress`)
+ * @param {string=} config.protocol - The type of protocol that this forwarding
+ *     rule matches. Valid values are `AH`, `ESP`, `SCTP`, `TCP`, `UDP`.
+ *     Default: `TCP`. (Alias for `config.IPProtocol`)
+ * @param {string=} config.range - A single port or single contiguous port
+ *     range, ranging from low to high for which this forwarding rule matches.
+ *     Packets of the specified protocol sent to these ports will be forwarded
+ *     on to the appropriate target pool or target instance. If this field is
+ *     left empty, then the forwarding matches traffic for all ports for the
+ *     specified protocol. (Alias for `config.portRange`)
+ * @param {string} config.target - The full or valid partial URL of the target
+ *     resource to receive the matched traffic. This target must be a global
+ *     [`TargetHttpProxy` or `TargetHttpsProxy` resource](https://cloud.google.com/compute/docs/load-balancing/http/target-proxies).
+ * @param {function} callback - The callback function.
+ * @param {?error} callback.err - An error returned while making this request.
+ * @param {module:compute/rule} callback.rule - The created Rule object.
+ * @param {module:compute/operation} callback.operation - An operation object
+ *     that can be used to check the status of the request.
+ * @param {object} callback.apiResponse - The full API response.
+ *
+ * @example
+ * var name = 'new-rule-name';
+ *
+ * var config = {
+ *   target: 'global/targetHttpProxies/my-proxy',
+ *   range: '8080-8089'
+ * };
+ *
+ * gce.createRule(name, config, function (err, rule, operation, apiResponse) {
+ *   // `rule` is a Rule object.
+ *
+ *   // `operation` is an Operation object that can be used to check the status
+ *   // of the request.
+ * });
+ */
+Compute.prototype.createRule = function(name, config, callback) {
+  var self = this;
+
+  var body = extend({}, config, {
+    name: name
+  });
+
+  if (body.ip) {
+    body.IPAddress = body.ip;
+    delete body.ip;
+  }
+
+  if (body.protocol) {
+    body.IPProtocol = body.protocol;
+    delete body.protocol;
+  }
+
+  if (body.range) {
+    body.portRange = body.range;
+    delete body.range;
+  }
+
+  this.request({
+    method: 'POST',
+    uri: '/global/forwardingRules',
+    json: body
+  }, function(err, resp) {
+    if (err) {
+      callback(err, null, null, resp);
+      return;
+    }
+
+    var rule = self.rule(name);
+
+    var operation = self.operation(resp.name);
+    operation.metadata = resp;
+
+    callback(null, rule, operation, resp);
+  });
+};
+
 /**
  * Create a backend service.
  *
@@ -1159,6 +1255,109 @@ Compute.prototype.getRegions = function(options, callback) {
   });
 };
 
+/**
+ * Get a list of forwading rules.
+ *
+ * @resource [GlobalForwardingRules: list API Documentation]{@link https://cloud.google.com/compute/docs/reference/v1/globalForwardingRules/list}
+ *
+ * @param {object=} options - Rules search options.
+ * @param {boolean} options.autoPaginate - Have pagination handled
+ *     automatically. Default: true.
+ * @param {string} options.filter - Search filter in the format of
+ *     `{name} {comparison} {filterString}`.
+ *     - **`name`**: the name of the field to compare
+ *     - **`comparison`**: the comparison operator, `eq` (equal) or `ne`
+ *       (not equal)
+ *     - **`filterString`**: the string to filter to. For string fields, this
+ *       can be a regular expression.
+ * @param {number} options.maxResults - Maximum number of rules to return.
+ * @param {string} options.pageToken - A previously-returned page token
+ *     representing part of the larger set of results to view.
+ * @param {function} callback - The callback function.
+ * @param {?error} callback.err - An error returned while making this request.
+ * @param {module:compute/rule} callback.rules - Rule objects from this region.
+ * @param {?object} callback.nextQuery - If present, query with this object to
+ *     check for more results.
+ * @param {object} callback.apiResponse - The full API response.
+ *
+ * @example
+ * gce.getRules(function(err, rules) {
+ *   // `rules` is an array of `Rule` objects.
+ * });
+ *
+ * //-
+ * // To control how many API requests are made and page through the results
+ * // manually, set `autoPaginate` to `false`.
+ * //-
+ * function callback(err, rules, nextQuery, apiResponse) {
+ *   if (nextQuery) {
+ *     // More results exist.
+ *     gce.getRules(nextQuery, callback);
+ *   }
+ * }
+ *
+ * gce.getRules({
+ *   autoPaginate: false
+ * }, callback);
+ *
+ * //-
+ * // Get the rules from your project as a readable object stream.
+ * //-
+ * gce.getRules()
+ *   .on('error', console.error)
+ *   .on('data', function(rule) {
+ *     // `rule` is a `Rule` object.
+ *   })
+ *   .on('end', function() {
+ *     // All rules retrieved.
+ *   });
+ *
+ * //-
+ * // If you anticipate many results, you can end a stream early to prevent
+ * // unnecessary processing and API requests.
+ * //-
+ * gce.getRules()
+ *   .on('data', function(rule) {
+ *     this.end();
+ *   });
+ */
+Compute.prototype.getRules = function(options, callback) {
+  var self = this;
+
+  if (is.fn(options)) {
+    callback = options;
+    options = {};
+  }
+
+  options = options || {};
+
+  this.request({
+    uri: '/global/forwardingRules',
+    qs: options
+  }, function(err, resp) {
+    if (err) {
+      callback(err, null, null, resp);
+      return;
+    }
+
+    var nextQuery = null;
+
+    if (resp.nextPageToken) {
+      nextQuery = extend({}, options, {
+        pageToken: resp.nextPageToken
+      });
+    }
+
+    var rules = (resp.items || []).map(function(rule) {
+      var ruleInstance = self.rule(rule.name);
+      ruleInstance.metadata = rule;
+      return ruleInstance;
+    });
+
+    callback(null, rules, nextQuery, resp);
+  });
+};
+
 /**
  * Get a list of backend services.
  *
@@ -1630,6 +1829,19 @@ Compute.prototype.region = function(name) {
   return new Region(this, name);
 };
 
+/**
+ * Get a reference to a Google Compute Engine forwading rule.
+ *
+ * @param {string} name - Name of the rule.
+ * @return {module:compute/rule}
+ *
+ * @example
+ * var rule = gce.rule('rule-name');
+ */
+Compute.prototype.rule = function(name) {
+  return new Rule(this, name);
+};
+
 /**
  * Get a reference to a Google Compute Engine backend service.
  *
@@ -1688,6 +1900,7 @@ streamRouter.extend(Compute, [
   'getNetworks',
   'getOperations',
   'getRegions',
+  'getRules',
   'getServices',
   'getSnapshots',
   'getVMs',