@spinnaker/google 0.0.0-main-2

package/src/loadBalancer/configure/http/httpLoadBalancer.write.service.js

@@ -0,0 +1,56 @@
+'use strict';
+
+import * as angular from 'angular';
+
+import { InfrastructureCaches, TaskExecutor } from '@spinnaker/core';
+
+export const GOOGLE_LOADBALANCER_CONFIGURE_HTTP_HTTPLOADBALANCER_WRITE_SERVICE =
+  'spinnaker.deck.gce.httpLoadBalancer.write.service';
+export const name = GOOGLE_LOADBALANCER_CONFIGURE_HTTP_HTTPLOADBALANCER_WRITE_SERVICE; // for backwards compatibility
+angular
+  .module(GOOGLE_LOADBALANCER_CONFIGURE_HTTP_HTTPLOADBALANCER_WRITE_SERVICE, [])
+  .factory('gceHttpLoadBalancerWriter', function () {
+    function upsertLoadBalancers(loadBalancers, application, descriptor) {
+      loadBalancers.forEach((lb) => {
+        angular.extend(lb, {
+          type: 'upsertLoadBalancer',
+          cloudProvider: 'gce',
+          loadBalancerName: lb.name,
+        });
+      });
+
+      InfrastructureCaches.clearCache('backendServices');
+      InfrastructureCaches.clearCache('healthChecks');
+
+      return TaskExecutor.executeTask({
+        job: loadBalancers,
+        application: application,
+        description: `${descriptor} Load Balancer: ${loadBalancers[0].urlMapName}`,
+      });
+    }
+
+    function deleteLoadBalancers(loadBalancer, application, params = {}) {
+      const job = {
+        type: 'deleteLoadBalancer',
+        loadBalancerName: loadBalancer.listeners[0].name,
+        regions: [loadBalancer.region || 'global'],
+        region: loadBalancer.region || 'global',
+        loadBalancerType: loadBalancer.loadBalancerType,
+        cloudProvider: loadBalancer.provider,
+        credentials: loadBalancer.account,
+      };
+
+      angular.extend(job, params);
+
+      InfrastructureCaches.clearCache('backendServices');
+      InfrastructureCaches.clearCache('healthChecks');
+
+      return TaskExecutor.executeTask({
+        job: [job],
+        application: application,
+        description: `Delete load balancer: ${loadBalancer.urlMapName} in ${loadBalancer.account}:global`,
+      });
+    }
+
+    return { upsertLoadBalancers, deleteLoadBalancers };
+  });

package/src/loadBalancer/configure/http/httpLoadBalancerWizard.component.less

@@ -0,0 +1,24 @@
+.gce-http-lb {
+  input[type='checkbox'] {
+    margin: 10px 0 0 5px;
+    position: absolute;
+  }
+
+  help-field.help-field-absolute {
+    span {
+      position: absolute;
+      top: 7px;
+      right: 2px;
+    }
+  }
+
+  .ui-select-multiple[tagging] {
+    width: 220px;
+  }
+
+  gce-host-rule {
+    hr.host-rule {
+      border-top: 1px solid var(--color-concrete);
+    }
+  }
+}

package/src/loadBalancer/configure/http/listeners/listener.component.html

@@ -0,0 +1,190 @@
+<hr ng-if="$ctrl.index > 0" />
+<div class="container-fluid form-horizontal">
+  <ng-form name="listener">
+    <div class="modal-body">
+      <div class="form-group">
+        <div
+          class="col-md-12 well"
+          ng-show="listener.stackName.$dirty || listener.detailName.$dirty || !$ctrl.listener.created"
+          ng-class="{
+            'alert-danger': listener.listenerName.$error.validateUnique,
+            'alert-info': !listener.listenerName.$error.validateUnique
+          }"
+        >
+          <strong>Your listener will be named:</strong>
+          <span>{{ $ctrl.getName($ctrl.listener, $ctrl.application.name) }}</span>
+          <!-- Angular does not seem to run length validation on hidden inputs, hence the text + display:none -->
+          <input
+            type="text"
+            style="display: none"
+            ng-maxlength="63"
+            class="form-control input-sm"
+            ng-model="$ctrl.listener.name"
+            ng-readonly="$ctrl.listener.created"
+            validate-unique="$ctrl.existingListenerNames()"
+            validate-ignore-case="true"
+            name="listenerName"
+          />
+          <validation-error
+            ng-if="listener.listenerName.$error.validateUnique || $ctrl.localListenerHasSameName()"
+            message="There is already a listener in {{ $ctrl.command.loadBalancer.credentials }} with that name."
+          >
+          </validation-error>
+        </div>
+
+        <div class="col-md-2 sm-label-right">Stack <help-field key="aws.loadBalancer.stack"></help-field></div>
+        <div class="col-md-3">
+          <input
+            type="text"
+            class="form-control input-sm"
+            ng-model="$ctrl.listener.stack"
+            ng-readonly="$ctrl.listener.created"
+            name="stackName"
+            ng-change="$ctrl.updateName($ctrl.listener, $ctrl.application.name)"
+            ng-pattern="/^[a-z0-9]*$/"
+          />
+        </div>
+        <div class="col-md-2 sm-label-right">Detail <help-field key="gce.loadBalancer.detail"></help-field></div>
+
+        <div class="col-md-3">
+          <input
+            type="text"
+            class="form-control input-sm"
+            ng-model="$ctrl.listener.detail"
+            ng-readonly="$ctrl.listener.created"
+            name="detailName"
+            ng-change="$ctrl.updateName($ctrl.listener, $ctrl.application.name)"
+            ng-pattern="/^[a-z0-9-]*$/"
+          />
+        </div>
+
+        <div class="col-md-1">
+          <button class="btn btn-sm btn-default" ng-click="$ctrl.deleteListener()">
+            <span class="glyphicon glyphicon-trash visible-lg-inline"></span>
+            <span>Delete</span>
+          </button>
+        </div>
+      </div>
+
+      <div class="form-group" ng-if="$ctrl.command.loadBalancer.loadBalancerType === 'INTERNAL_MANAGED'">
+        <div class="col-md-2 sm-label-right">Subnet</div>
+        <div class="col-md-8">
+          <select
+            class="form-control input-sm"
+            ng-model="$ctrl.listener.subnet"
+            ng-disabled="$ctrl.listener.created"
+            ng-required="true"
+          >
+            <option
+              ng-repeat="subnet in $ctrl.getSubnets()"
+              value="{{ subnet }}"
+              ng-selected="$ctrl.listener.subnet === subnet"
+            >
+              {{ subnet }}
+            </option>
+          </select>
+        </div>
+      </div>
+
+      <div class="form-group" ng-if="$ctrl.command.loadBalancer.loadBalancerType === 'INTERNAL_MANAGED'">
+        <div class="col-md-2 sm-label-right">Internal IP</div>
+        <div class="col-md-8">
+          <select
+            class="form-control input-sm"
+            ng-model="$ctrl.listener.ipAddress"
+            ng-disabled="$ctrl.listener.created"
+            ng-required="true"
+          >
+            <option
+              ng-repeat="address in $ctrl.getInternalAddresses()"
+              value="{{ address.address }}"
+              ng-selected="$ctrl.listener.ipAddress === address.address"
+            >
+              {{ address.name }}
+            </option>
+          </select>
+        </div>
+      </div>
+
+      <div class="form-group">
+        <div class="col-md-2 sm-label-right">Port<help-field key="gce.httpLoadBalancer.port"></help-field></div>
+        <div class="col-md-3">
+          <ui-select
+            ng-model="$ctrl.listener.port"
+            ng-disabled="$ctrl.listener.created"
+            required
+            class="form-control input-sm"
+          >
+            <ui-select-match>
+              <span>{{ $select.selected }}</span>
+            </ui-select-match>
+            <ui-select-choices repeat="choice as choice in [8080, 80, 443]">
+              <span>{{ choice }}</span>
+            </ui-select-choices>
+          </ui-select>
+        </div>
+        <div ng-if="$ctrl.isHttps($ctrl.listener.port)">
+          <div class="col-md-2 sm-label-right">
+            Certificate
+            <help-field key="gce.httpLoadBalancer.certificate" class="help-field-absolute"></help-field>
+          </div>
+          <div class="col-md-3">
+            <ui-select
+              ng-model="$ctrl.listener.certificate"
+              ng-disabled="$ctrl.listener.created && !$ctrl.listener.certificate"
+              required
+              class="form-control input-sm"
+            >
+              <ui-select-match allow-clear placeholder="Select...">{{ $select.selected }}</ui-select-match>
+              <ui-select-choices repeat="certificate in $ctrl.getCertificates() | filter: $select.search">
+                <span ng-bind-html="certificate | highlight: $select.search"></span>
+              </ui-select-choices>
+            </ui-select>
+          </div>
+          <div class="col-md-1" style="padding-left: 0; margin-top: 4px">
+            <gce-cache-refresh
+              cache-key="certificates"
+              render-compact="true"
+              on-refresh="$ctrl.command.onCertificateRefresh($ctrl.command)"
+            ></gce-cache-refresh>
+          </div>
+        </div>
+      </div>
+
+      <div class="form-group" ng-if="$ctrl.command.loadBalancer.loadBalancerType === 'HTTP'">
+        <div class="col-md-2 sm-label-right">
+          External IP
+          <help-field key="gce.httpLoadBalancer.externalIP" class="help-field-absolute"></help-field>
+        </div>
+        <div class="col-md-5">
+          <gce-address-selector
+            address-list="$ctrl.command.backingData.addresses"
+            read-only="$ctrl.listener.created"
+            account="$ctrl.command.loadBalancer.credentials"
+            initial-ip-address="$ctrl.listener.ipAddress"
+            on-address-select="$ctrl.onAddressSelect(address)"
+          ></gce-address-selector>
+        </div>
+        <div class="col-md-1" style="padding-left: 0; margin-top: 4px">
+          <gce-cache-refresh
+            ng-if="!$ctrl.listener.created"
+            cache-key="addresses"
+            render-compact="true"
+            on-refresh="$ctrl.command.onAddressRefresh($ctrl.command)"
+          ></gce-cache-refresh>
+        </div>
+      </div>
+
+      <div class="form-group">
+        <div class="col-md-7 col-md-offset-2" ng-if="listener.stackName.$error.pattern">
+          <validation-error message="Stack can only contain lowercase letters and numbers."></validation-error>
+        </div>
+        <div class="col-md-7 col-md-offset-2" ng-if="listener.detailName.$error.pattern">
+          <validation-error
+            message="Detail can only contain lowercase letters, numbers, and dashes(-)."
+          ></validation-error>
+        </div>
+      </div>
+    </div>
+  </ng-form>
+</div>

package/src/loadBalancer/configure/http/listeners/listener.component.js

@@ -0,0 +1,82 @@
+'use strict';
+
+import { module } from 'angular';
+import _ from 'lodash';
+
+import { GCE_ADDRESS_SELECTOR } from '../../common/addressSelector.component';
+
+export const GOOGLE_LOADBALANCER_CONFIGURE_HTTP_LISTENERS_LISTENER_COMPONENT =
+  'spinnaker.deck.gce.httpLoadBalancer.listener.component';
+export const name = GOOGLE_LOADBALANCER_CONFIGURE_HTTP_LISTENERS_LISTENER_COMPONENT; // for backwards compatibility
+module(GOOGLE_LOADBALANCER_CONFIGURE_HTTP_LISTENERS_LISTENER_COMPONENT, [GCE_ADDRESS_SELECTOR]).component(
+  'gceListener',
+  {
+    bindings: {
+      command: '=',
+      listener: '=',
+      deleteListener: '&',
+      index: '=',
+      application: '=',
+    },
+    templateUrl: require('./listener.component.html'),
+    controller: function () {
+      this.$onInit = () => {
+        this.certificates = this.command.backingData.certificates;
+        const loadBalancerMap = this.command.backingData.loadBalancerMap;
+
+        this.getName = (listener, applicationName) => {
+          const listenerName = [applicationName, listener.stack || '', listener.detail || ''].join('-');
+          return _.trimEnd(listenerName, '-');
+        };
+
+        this.getCertificates = () => {
+          return this.command.backingData.certificates
+            .filter((certificate) => certificate.account === this.command.loadBalancer.credentials)
+            .map((certificate) => certificate.name);
+        };
+
+        this.getSubnets = () => {
+          const ret = this.command.backingData.subnetMap[this.command.loadBalancer.network]
+            .filter((subnet) => subnet.region === this.command.loadBalancer.region)
+            .map((subnet) => subnet.name);
+          return _.uniq(ret);
+        };
+
+        this.getInternalAddresses = () => {
+          return this.command.backingData.addresses.filter(
+            (address) =>
+              address.addressType === 'INTERNAL' && address.subnetwork.split('/').pop() === this.listener.subnet,
+          );
+        };
+
+        this.updateName = (listener, appName) => {
+          listener.name = this.getName(listener, appName);
+        };
+
+        this.localListenerHasSameName = () => {
+          return (
+            this.command.loadBalancer.listeners.filter((listener) => listener.name === this.listener.name).length > 1
+          );
+        };
+
+        this.existingListenerNames = () => {
+          return _.get(loadBalancerMap, [this.command.loadBalancer.credentials, 'listeners']);
+        };
+
+        this.isHttps = (port) => port === 443 || port === '443';
+
+        if (!this.listener.name) {
+          this.updateName(this.listener, this.application.name);
+        }
+
+        this.onAddressSelect = (address) => {
+          if (address) {
+            this.listener.ipAddress = address.address;
+          } else {
+            this.listener.ipAddress = null;
+          }
+        };
+      };
+    },
+  },
+);

package/src/loadBalancer/configure/http/listeners/listeners.html

@@ -0,0 +1,17 @@
+<ng-form name="listeners">
+  <gce-listener
+    command="ctrl.command"
+    delete-listener="ctrl.remove('listeners', $index)"
+    index="$index"
+    application="ctrl.application"
+    listener="listener"
+    ng-repeat="listener in ctrl.command.loadBalancer.listeners"
+  ></gce-listener>
+  <div class="row">
+    <div class="col-md-12">
+      <button class="add-new btn btn-block" ng-click="ctrl.add('listeners')">
+        <span class="glyphicon glyphicon-plus-sign"></span> Add listener
+      </button>
+    </div>
+  </div>
+</ng-form>

package/src/loadBalancer/configure/http/pathRule/pathRule.component.html

@@ -0,0 +1,51 @@
+<hr />
+<div class="form-group">
+  <div class="col-md-4 sm-label-right">
+    Paths
+    <help-field key="gce.httpLoadBalancer.pathRule.paths"> </help-field>
+  </div>
+  <div class="col-md-4">
+    <ui-select
+      multiple
+      tagging
+      tagging-label=""
+      ng-model="$ctrl.pathRule.paths"
+      sortable="true"
+      class="form-control input-sm"
+      required
+    >
+      <ui-select-match>{{ $item }}</ui-select-match>
+      <ui-select-choices repeat="path in []">
+        {{ path }}
+      </ui-select-choices>
+    </ui-select>
+  </div>
+  <div class="col-md-1">
+    <button class="btn btn-sm btn-default" ng-click="$ctrl.deletePathRule()">
+      <span class="glyphicon glyphicon-trash visible-lg-inline"></span>
+      <span>Delete</span>
+    </button>
+  </div>
+</div>
+
+<div class="form-group">
+  <div class="col-md-4 sm-label-right">
+    <b>Backend Service</b>
+  </div>
+  <div class="col-md-4">
+    <ui-select
+      ng-model="$ctrl.pathRule.backendService"
+      on-select="$ctrl.command.onBackendServiceSelected($item, $ctrl.command)"
+      class="form-control input-sm"
+    >
+      <ui-select-match placeholder="Select...">
+        {{ $select.selected }}
+      </ui-select-match>
+      <ui-select-choices
+        repeat="backendService in $ctrl.command.getAllBackendServices($ctrl.command) | filter: $select.search"
+      >
+        <div ng-bind-html="backendService | highlight: $select.search"></div>
+      </ui-select-choices>
+    </ui-select>
+  </div>
+</div>

package/src/loadBalancer/configure/http/pathRule/pathRule.component.js

@@ -0,0 +1,16 @@
+'use strict';
+
+import { module } from 'angular';
+
+export const GOOGLE_LOADBALANCER_CONFIGURE_HTTP_PATHRULE_PATHRULE_COMPONENT =
+  'spinnaker.deck.gce.httpLoadBalancer.pathRule.component';
+export const name = GOOGLE_LOADBALANCER_CONFIGURE_HTTP_PATHRULE_PATHRULE_COMPONENT; // for backwards compatibility
+module(GOOGLE_LOADBALANCER_CONFIGURE_HTTP_PATHRULE_PATHRULE_COMPONENT, []).component('gcePathRule', {
+  bindings: {
+    pathRule: '=',
+    command: '=',
+    index: '=',
+    deletePathRule: '&',
+  },
+  templateUrl: require('./pathRule.component.html'),
+});

package/src/loadBalancer/configure/http/templates.ts

@@ -0,0 +1,48 @@
+export class HttpLoadBalancerTemplate {
+  public provider = 'gce';
+  public stack = '';
+  public detail = '';
+  public region = 'global';
+  public loadBalancerType = 'HTTP';
+  public certificate = '';
+  public defaultService: BackendServiceTemplate;
+  public hostRules: HostRuleTemplate[] = [];
+  public listeners: ListenerTemplate[] = [];
+
+  constructor(public credentials: string | null) {}
+}
+
+export class BackendServiceTemplate {
+  public backends: any[] = [];
+  public healthCheck: HealthCheckTemplate;
+  public sessionAffinity = 'NONE';
+  public affinityCookieTtlSec: number | null = null;
+}
+
+export class HealthCheckTemplate {
+  public requestPath = '/';
+  public port = 80;
+  public checkIntervalSec = 10;
+  public timeoutSec = 5;
+  public healthyThreshold = 10;
+  public unhealthyThreshold = 2;
+}
+
+export class PathMatcherTemplate {
+  public pathRules: PathRuleTemplate[] = [];
+}
+
+export class HostRuleTemplate {
+  public hostPatterns: string[];
+  public pathMatcher: PathMatcherTemplate = new PathMatcherTemplate();
+}
+
+export class PathRuleTemplate {
+  public paths: string[];
+}
+
+export class ListenerTemplate {
+  public name: string;
+  public port: number;
+  public certificate: string | null = null;
+}

package/src/loadBalancer/configure/http/transformer.service.js

@@ -0,0 +1,176 @@
+'use strict';
+
+import { module } from 'angular';
+import _ from 'lodash';
+
+import { NameUtils } from '@spinnaker/core';
+
+import { sessionAffinityModelToViewMap, sessionAffinityViewToModelMap } from '../common/sessionAffinityNameMaps';
+
+export const GOOGLE_LOADBALANCER_CONFIGURE_HTTP_TRANSFORMER_SERVICE = 'spinnaker.gce.deck.httpLoadBalancer.transformer';
+export const name = GOOGLE_LOADBALANCER_CONFIGURE_HTTP_TRANSFORMER_SERVICE; // for backwards compatibility
+module(GOOGLE_LOADBALANCER_CONFIGURE_HTTP_TRANSFORMER_SERVICE, []).factory(
+  'gceHttpLoadBalancerTransformer',
+  function () {
+    // SERIALIZE
+
+    const keysToOmit = ['backendServices', 'healthChecks', 'listeners', 'stack', 'detail'];
+
+    function serialize(originalCommand, originalLoadBalancer) {
+      const command = _.cloneDeep(originalCommand);
+      const { loadBalancer, backingData } = command;
+
+      mapComponentNamesToObjects(loadBalancer, backingData);
+
+      loadBalancer.hostRules = loadBalancer.hostRules.reduce((hostRules, hostRule) => {
+        return hostRules.concat(
+          hostRule.hostPatterns.map((hostPattern) => {
+            return {
+              hostPatterns: [hostPattern],
+              pathMatcher: _.cloneDeep(hostRule.pathMatcher),
+            };
+          }),
+        );
+      }, []);
+
+      const commands = buildCommandForEachListener(loadBalancer);
+
+      if (originalLoadBalancer) {
+        commands[0].listenersToDelete = _.chain(originalLoadBalancer.listeners)
+          .map('name')
+          .difference(_.map(originalCommand.loadBalancer.listeners, 'name'))
+          .value();
+      }
+
+      return commands;
+    }
+
+    function mapComponentNamesToObjects(loadBalancer, backingData) {
+      const unifiedHealthChecksKeyedByName = _.assign(
+        backingData.healthChecksKeyedByName,
+        _.keyBy(loadBalancer.healthChecks, 'name'),
+      );
+      const unifiedBackendServicesKeyedByName = _.assign(
+        backingData.backendServicesKeyedByName,
+        _.keyBy(loadBalancer.backendServices, 'name'),
+      );
+
+      _.forEach(unifiedBackendServicesKeyedByName, (service) => {
+        service.healthCheck = unifiedHealthChecksKeyedByName[service.healthCheck];
+        // Map human readable text back to session affinity code.
+        service.sessionAffinity = sessionAffinityViewToModelMap[service.sessionAffinity] || service.sessionAffinity;
+      });
+
+      loadBalancer.defaultService = unifiedBackendServicesKeyedByName[loadBalancer.defaultService];
+      mapBackendServiceNamesToObjects(loadBalancer.hostRules, unifiedBackendServicesKeyedByName);
+    }
+
+    function mapBackendServiceNamesToObjects(hostRules, servicesByName) {
+      hostRules.forEach((hostRule) => {
+        const p = hostRule.pathMatcher;
+
+        p.defaultService = servicesByName[p.defaultService];
+
+        p.pathRules.forEach((pathRule) => {
+          pathRule.backendService = servicesByName[pathRule.backendService];
+        });
+      });
+    }
+
+    function buildCommandForEachListener(loadBalancer) {
+      return loadBalancer.listeners.map((listener) => {
+        let command = _.cloneDeep(loadBalancer);
+        command = _.omit(command, keysToOmit);
+        command.name = listener.name;
+        command.portRange = listener.port;
+        command.certificate = listener.certificate || null;
+        command.ipAddress = listener.ipAddress;
+        command.subnet = listener.subnet;
+
+        return command;
+      });
+    }
+
+    // DESERIALIZE
+
+    function deserialize(loadBalancer) {
+      const { backendServices, healthChecks, defaultService } = getHealthChecksAndBackendServices(loadBalancer);
+      const hostRules = getHostRules(loadBalancer);
+      const listeners = getListeners(loadBalancer);
+
+      return {
+        defaultService: defaultService.name,
+        backendServices,
+        healthChecks,
+        hostRules,
+        listeners,
+        network: loadBalancer.network,
+        region: loadBalancer.region,
+        urlMapName: loadBalancer.urlMapName,
+        credentials: loadBalancer.credentials || loadBalancer.account,
+      };
+    }
+
+    function getHealthChecksAndBackendServices(loadBalancer) {
+      const defaultService = loadBalancer.defaultService;
+      let backendServices = [loadBalancer.defaultService];
+
+      if (loadBalancer.hostRules) {
+        backendServices = loadBalancer.hostRules.reduce((services, hostRule) => {
+          services = services.concat(hostRule.pathMatcher.defaultService);
+          return hostRule.pathMatcher.pathRules.reduce(
+            (services, pathRule) => services.concat(pathRule.backendService),
+            services,
+          );
+        }, backendServices);
+      }
+
+      const healthChecks = _.chain(backendServices).map('healthCheck').uniqBy('name').cloneDeep().value();
+      healthChecks.forEach((hc) => {
+        hc.account = loadBalancer.account || loadBalancer.credentials;
+      });
+      backendServices = _.uniqBy(backendServices, 'name');
+
+      backendServices.forEach((service) => {
+        // Map health check to health check name so we don't have to deal with object references
+        service.healthCheck = service.healthCheck.name;
+        // Map session affinity code to more human readable text.
+        service.sessionAffinity = sessionAffinityModelToViewMap[service.sessionAffinity] || service.sessionAffinity;
+      });
+
+      return { backendServices, healthChecks, defaultService };
+    }
+
+    function getHostRules(loadBalancer) {
+      return mapBackendServicesToNames(_.cloneDeep(loadBalancer.hostRules));
+    }
+
+    function getListeners(loadBalancer) {
+      loadBalancer.listeners.forEach((listener) => {
+        const { stack, freeFormDetails } = NameUtils.parseLoadBalancerName(listener.name);
+        listener.stack = stack;
+        listener.detail = freeFormDetails;
+        listener.created = true;
+      });
+
+      return loadBalancer.listeners;
+    }
+
+    function mapBackendServicesToNames(hostRules) {
+      // Map backend service to backend service name so we don't have to deal with object references
+      hostRules.forEach((hostRule) => {
+        const p = hostRule.pathMatcher;
+
+        p.defaultService = p.defaultService.name;
+
+        p.pathRules.forEach((pathRule) => {
+          pathRule.backendService = pathRule.backendService.name;
+        });
+      });
+
+      return hostRules;
+    }
+
+    return { serialize, deserialize };
+  },
+);