@spinnaker/kubernetes 0.0.0-main-2

package/src/serverGroup/details/details.controller.ts

@@ -0,0 +1,207 @@
+import type { StateService } from '@uirouter/angularjs';
+import type { IController, IQService, IScope } from 'angular';
+import { module } from 'angular';
+import type { IModalService } from 'angular-ui-bootstrap';
+
+import type { Application, IManifest, IOwnerOption, IServerGroup } from '@spinnaker/core';
+import {
+  ClusterTargetBuilder,
+  ConfirmationModalService,
+  ManifestReader,
+  SERVER_GROUP_WRITER,
+  ServerGroupReader,
+  SETTINGS,
+} from '@spinnaker/core';
+
+import type { IKubernetesServerGroup } from '../../interfaces';
+import { KubernetesManifestCommandBuilder } from '../../manifest/manifestCommandBuilder.service';
+import { ManifestTrafficService } from '../../manifest/traffic/ManifestTrafficService';
+import { ManifestWizard } from '../../manifest/wizard/ManifestWizard';
+
+interface IServerGroupFromStateParams {
+  accountId: string;
+  region: string;
+  name: string;
+}
+
+class KubernetesServerGroupDetailsController implements IController {
+  public state = { loading: true };
+  public serverGroup: IKubernetesServerGroup;
+  public manifest: IManifest;
+  public entityTagTargets: IOwnerOption[];
+
+  public static $inject = ['serverGroup', 'app', '$uibModal', '$scope', '$state', '$q'];
+  constructor(
+    serverGroup: IServerGroupFromStateParams,
+    public app: Application,
+    private $uibModal: IModalService,
+    private $scope: IScope,
+    private $state: StateService,
+    private $q: IQService,
+  ) {
+    const dataSource = this.app.getDataSource('serverGroups');
+    dataSource
+      .ready()
+      .then(() => {
+        this.extractServerGroup(serverGroup);
+        this.$scope.isDisabled = !SETTINGS.kubernetesAdHocInfraWritesEnabled;
+        dataSource.onRefresh(this.$scope, () => this.extractServerGroup(serverGroup));
+      })
+      .catch(() => this.autoClose());
+  }
+
+  private ownerReferences(): any[] {
+    const manifest = this.manifest.manifest;
+    if (
+      manifest != null &&
+      manifest.hasOwnProperty('metadata') &&
+      manifest.metadata.hasOwnProperty('ownerReferences') &&
+      Array.isArray(manifest.metadata.ownerReferences)
+    ) {
+      return manifest.metadata.ownerReferences;
+    } else {
+      return [] as any[];
+    }
+  }
+
+  private ownerIsController(ownerReference: any): boolean {
+    return ownerReference.hasOwnProperty('controller') && ownerReference.controller === true;
+  }
+
+  private lowerCaseFirstLetter(s: string): string {
+    return s.charAt(0).toLowerCase() + s.slice(1);
+  }
+
+  public manifestController(): string {
+    const controller = this.ownerReferences().find(this.ownerIsController);
+    if (typeof controller === 'undefined') {
+      return null;
+    } else {
+      return this.lowerCaseFirstLetter(controller.kind) + ' ' + controller.name;
+    }
+  }
+
+  public canScaleServerGroup(): boolean {
+    return this.serverGroup.kind !== 'DaemonSet' && this.manifestController() === null;
+  }
+
+  public scaleServerGroup(): void {
+    this.$uibModal.open({
+      templateUrl: require('../../manifest/scale/scale.html'),
+      controller: 'kubernetesV2ManifestScaleCtrl',
+      controllerAs: 'ctrl',
+      resolve: {
+        coordinates: {
+          name: this.serverGroup.name,
+          namespace: this.serverGroup.namespace,
+          account: this.serverGroup.account,
+        },
+        currentReplicas: this.manifest.manifest.spec.replicas,
+        application: this.app,
+      },
+    });
+  }
+
+  public canEditServerGroup(): boolean {
+    return this.manifestController() === null;
+  }
+
+  public editServerGroup(): void {
+    KubernetesManifestCommandBuilder.buildNewManifestCommand(
+      this.app,
+      this.manifest.manifest,
+      this.serverGroup.moniker,
+      this.serverGroup.account,
+    ).then((builtCommand) => {
+      ManifestWizard.show({ title: 'Edit Manifest', application: this.app, command: builtCommand });
+    });
+  }
+
+  public deleteServerGroup(): void {
+    this.$uibModal.open({
+      templateUrl: require('../../manifest/delete/delete.html'),
+      controller: 'kubernetesV2ManifestDeleteCtrl',
+      controllerAs: 'ctrl',
+      resolve: {
+        coordinates: {
+          name: this.serverGroup.name,
+          namespace: this.serverGroup.namespace,
+          account: this.serverGroup.account,
+        },
+        manifestController: () => this.manifestController(),
+        application: this.app,
+      },
+    });
+  }
+
+  public canDisable = () => ManifestTrafficService.canDisableServerGroup(this.serverGroup);
+
+  public disableServerGroup = (): void => {
+    ConfirmationModalService.confirm({
+      header: `Really disable ${this.manifest.name}?`,
+      buttonText: 'Disable',
+      askForReason: true,
+      submitJustWithReason: true,
+      submitMethod: ({ reason }: { reason: string }) => ManifestTrafficService.disable(this.manifest, this.app, reason),
+      taskMonitorConfig: {
+        application: this.app,
+        title: `Disabling ${this.manifest.name}`,
+        onTaskComplete: () => this.app.getDataSource('serverGroups').refresh(),
+      },
+    });
+  };
+
+  public canEnable = () => ManifestTrafficService.canEnableServerGroup(this.serverGroup);
+
+  public enableServerGroup = (): void => {
+    ConfirmationModalService.confirm({
+      header: `Really enable ${this.manifest.name}?`,
+      buttonText: 'Enable',
+      askForReason: true,
+      submitJustWithReason: true,
+      submitMethod: ({ reason }: { reason: string }) => ManifestTrafficService.enable(this.manifest, this.app, reason),
+      taskMonitorConfig: {
+        application: this.app,
+        title: `Enabling ${this.manifest.name}`,
+        onTaskComplete: () => this.app.getDataSource('serverGroups').refresh(),
+      },
+    });
+  };
+
+  private autoClose(): void {
+    if (this.$scope.$$destroyed) {
+      return;
+    } else {
+      this.$state.params.allowModalToStayOpen = true;
+      this.$state.go('^', null, { location: 'replace' });
+    }
+  }
+
+  private extractServerGroup({ accountId, name, region }: IServerGroupFromStateParams): void {
+    this.$q
+      .all([
+        ServerGroupReader.getServerGroup(this.app.name, accountId, region, name),
+        ManifestReader.getManifest(accountId, region, name),
+      ])
+      .then(([serverGroupDetails, manifest]: [IServerGroup, IManifest]) => {
+        if (!serverGroupDetails) {
+          return this.autoClose();
+        }
+        this.serverGroup = serverGroupDetails as IKubernetesServerGroup;
+        this.entityTagTargets = this.configureEntityTagTargets();
+        this.manifest = manifest;
+        this.state.loading = false;
+      });
+  }
+
+  private configureEntityTagTargets(): IOwnerOption[] {
+    return ClusterTargetBuilder.buildClusterTargets(this.serverGroup);
+  }
+}
+
+export const KUBERNETES_SERVER_GROUP_DETAILS_CTRL = 'spinnaker.kubernetes.serverGroup.details.controller';
+
+module(KUBERNETES_SERVER_GROUP_DETAILS_CTRL, [SERVER_GROUP_WRITER]).controller(
+  'kubernetesV2ServerGroupDetailsCtrl',
+  KubernetesServerGroupDetailsController,
+);

package/src/serverGroup/details/details.html

@@ -0,0 +1,153 @@
+<div class="details-panel" ng-class="{disabled: ctrl.serverGroup.isDisabled || ctrl.serverGroup.disabled}">
+  <div class="header" ng-if="ctrl.state.loading">
+    <div class="close-button">
+      <a class="btn btn-link" ui-sref="^">
+        <span class="glyphicon glyphicon-remove"></span>
+      </a>
+    </div>
+    <h4 class="text-center">
+      <span us-spinner="{radius:20, width:6, length: 12}"></span>
+    </h4>
+  </div>
+
+  <div class="header" ng-if="!ctrl.state.loading">
+    <div class="close-button">
+      <a class="btn btn-link" ui-sref="^">
+        <span class="glyphicon glyphicon-remove"></span>
+      </a>
+    </div>
+    <div class="header-text horizontal middle">
+      <cloud-provider-logo
+        provider="ctrl.serverGroup.cloudProvider"
+        height="'36px'"
+        width="'36px'"
+      ></cloud-provider-logo>
+      <h3 class="horizontal middle space-between flex-1" select-on-dbl-click>
+        {{ctrl.serverGroup.displayName}}
+        <render-if-feature feature="entityTags">
+          <entity-notifications
+            entity="ctrl.serverGroup"
+            application="ctrl.app"
+            placement="bottom"
+            h-offset-percent="90%"
+            entity-type="serverGroup"
+            page-location="details"
+            on-update="ctrl.app.serverGroups.refresh()"
+          ></entity-notifications>
+        </render-if-feature>
+      </h3>
+    </div>
+    <div class="actions">
+      <div class="dropdown" uib-dropdown dropdown-append-to-body>
+        <button type="button" class="btn btn-sm btn-primary dropdown-toggle" uib-dropdown-toggle ng-hide="isDisabled">
+          {{ctrl.serverGroup.kind | robotToHuman}} Actions <span class="caret"></span>
+        </button>
+        <ul class="dropdown-menu" uib-dropdown-menu role="menu">
+          <li ng-if="ctrl.canEditServerGroup()">
+            <a href ng-click="ctrl.editServerGroup()"> Edit </a>
+          </li>
+          <li ng-if="ctrl.canScaleServerGroup()">
+            <a href ng-click="ctrl.scaleServerGroup()"> Scale </a>
+          </li>
+          <li ng-if="ctrl.canEnable()">
+            <a href ng-click="ctrl.enableServerGroup()"> Enable </a>
+          </li>
+          <li ng-if="ctrl.canDisable()">
+            <a href ng-click="ctrl.disableServerGroup()"> Disable </a>
+          </li>
+          <li>
+            <a href ng-click="ctrl.deleteServerGroup()"> Delete </a>
+          </li>
+          <render-if-feature feature="entityTags">
+            <add-entity-tag-links
+              component="ctrl.serverGroup"
+              application="ctrl.app"
+              entity-type="serverGroup"
+              owner-options="ctrl.entityTagTargets"
+              on-update="ctrl.app.serverGroups.refresh"
+            ></add-entity-tag-links>
+          </render-if-feature>
+        </ul>
+      </div>
+    </div>
+  </div>
+  <div class="content" ng-if="!ctrl.state.loading">
+    <kubernetes-manifest-status status="ctrl.manifest.status"></kubernetes-manifest-status>
+    <div class="band band-info" ng-if="ctrl.serverGroup.isDisabled || ctrl.serverGroup.disabled">Disabled</div>
+    <server-group-running-tasks-details
+      server-group="ctrl.serverGroup"
+      application="ctrl.app"
+    ></server-group-running-tasks-details>
+    <collapsible-section heading="Information" expanded="true">
+      <dl class="dl-horizontal dl-narrow">
+        <dt>Created</dt>
+        <dd>{{ctrl.serverGroup.createdTime | timestamp}}</dd>
+        <dt>Account</dt>
+        <dd><account-tag account="ctrl.serverGroup.account"></account-tag></dd>
+        <dt>Namespace</dt>
+        <dd>{{ctrl.serverGroup.namespace}}</dd>
+        <dt>Kind</dt>
+        <dd>{{ctrl.serverGroup.kind}}</dd>
+        <dt ng-if="ctrl.manifestController()">Controller</dt>
+        <dd>
+          <a
+            ui-sref="^.serverGroupManager({
+                        accountId: ctrl.serverGroup.account,
+                        region: ctrl.serverGroup.region,
+                        serverGroupManager: ctrl.manifestController(),
+                        provider: 'kubernetes'})"
+          >
+            {{ctrl.manifestController() | robotToHuman }}
+          </a>
+        </dd>
+      </dl>
+    </collapsible-section>
+
+    <kubernetes-annotation-custom-sections
+      manifest="ctrl.manifest.manifest"
+      resource="ctrl.serverGroup"
+    ></kubernetes-annotation-custom-sections>
+
+    <collapsible-section heading="Images" expanded="true">
+      <kubernetes-manifest-image-details manifest="ctrl.manifest.manifest"></kubernetes-manifest-image-details>
+    </collapsible-section>
+
+    <collapsible-section heading="Events" expanded="true">
+      <kubernetes-manifest-events manifest="ctrl.manifest"></kubernetes-manifest-events>
+    </collapsible-section>
+    <collapsible-section heading="Labels" expanded="true">
+      <kubernetes-manifest-labels manifest="ctrl.manifest.manifest"></kubernetes-manifest-labels>
+    </collapsible-section>
+    <collapsible-section heading="Size" expanded="true">
+      <dl class="dl-horizontal dl-narrow" ng-if="ctrl.serverGroup.capacity.min == null">
+        <dt>Current</dt>
+        <dd>{{ctrl.serverGroup.instances.length}}</dd>
+      </dl>
+      <dl
+        class="dl-horizontal dl-narrow"
+        ng-if="ctrl.serverGroup.capacity.min != null && ctrl.serverGroup.capacity.min === ctrl.serverGroup.capacity.max"
+      >
+        <dt>Min/Max</dt>
+        <dd>{{ctrl.serverGroup.capacity.min}}</dd>
+        <dt>Current</dt>
+        <dd>{{ctrl.serverGroup.instances.length}}</dd>
+      </dl>
+      <dl class="dl-horizontal dl-narrow" ng-if="ctrl.serverGroup.capacity.min !== ctrl.serverGroup.capacity.max">
+        <dt>Min</dt>
+        <dd>{{ctrl.serverGroup.capacity.min}}</dd>
+        <dt>Max</dt>
+        <dd>{{ctrl.serverGroup.capacity.max}}</dd>
+        <dt>Current</dt>
+        <dd>{{ctrl.serverGroup.instances.length}}</dd>
+      </dl>
+    </collapsible-section>
+    <collapsible-section heading="Health" expanded="true">
+      <dl class="dl-horizontal dl-narrow" ng-if="ctrl.serverGroup">
+        <dt>Instances</dt>
+        <dd>
+          <health-counts container="ctrl.serverGroup.instanceCounts" class="pull-left"></health-counts>
+        </dd>
+      </dl>
+    </collapsible-section>
+  </div>
+</div>

package/src/serverGroup/details/resize/resize.controller.ts

@@ -0,0 +1,73 @@
+import type { IController } from 'angular';
+import { copy, equals, module } from 'angular';
+import type { IModalServiceInstance } from 'angular-ui-bootstrap';
+
+import type { Application, ICapacity, ServerGroupWriter } from '@spinnaker/core';
+import { SERVER_GROUP_WRITER, TaskMonitor } from '@spinnaker/core';
+import type { IKubernetesServerGroup } from '../../../interfaces';
+
+interface IResizeCommand {
+  capacity: ICapacity;
+  reason: string;
+}
+
+class KubernetesServerGroupResizeController implements IController {
+  public taskMonitor: TaskMonitor;
+  public command: IResizeCommand;
+  public current: ICapacity;
+  public verification = {
+    verified: false,
+  };
+
+  public static $inject = ['serverGroup', '$uibModalInstance', 'serverGroupWriter', 'application'];
+  constructor(
+    public serverGroup: IKubernetesServerGroup,
+    private $uibModalInstance: IModalServiceInstance,
+    private serverGroupWriter: ServerGroupWriter,
+    private application: Application,
+  ) {
+    this.taskMonitor = new TaskMonitor({
+      title: `Resizing ${this.serverGroup.name}`,
+      application,
+      modalInstance: $uibModalInstance,
+    });
+
+    this.current = this.serverGroup.capacity;
+    this.command = {
+      capacity: copy(this.current),
+      reason: null,
+    };
+  }
+
+  public isValid(): boolean {
+    return (
+      this.verification.verified && this.command.capacity.desired >= 0 && !equals(this.command.capacity, this.current)
+    );
+  }
+
+  public cancel(): void {
+    this.$uibModalInstance.dismiss();
+  }
+
+  public resize(): void {
+    this.taskMonitor.submit(() => {
+      const payload = {
+        capacity: this.command.capacity,
+        serverGroupName: this.serverGroup.name,
+        account: this.serverGroup.account,
+        region: this.serverGroup.region,
+        interestingHealthProviderNames: ['KubernetesPod'],
+        reason: this.command.reason,
+      };
+
+      return this.serverGroupWriter.resizeServerGroup(this.serverGroup, this.application, payload);
+    });
+  }
+}
+
+export const KUBERNETES_SERVER_GROUP_RESIZE_CTRL = 'spinnaker.kubernetes.serverGroup.details.resize.controller';
+
+module(KUBERNETES_SERVER_GROUP_RESIZE_CTRL, [SERVER_GROUP_WRITER]).controller(
+  'kubernetesV2ServerGroupResizeCtrl',
+  KubernetesServerGroupResizeController,
+);

package/src/serverGroup/details/resize/resize.html

@@ -0,0 +1,57 @@
+<div modal-page class="confirmation-modal">
+  <task-monitor monitor="ctrl.taskMonitor"></task-monitor>
+  <form role="form" name="resizeForm">
+    <modal-close dismiss="$dismiss()"></modal-close>
+    <div class="modal-header">
+      <h4 class="modal-title">Resize {{ctrl.serverGroup.kind}} {{ctrl.serverGroup.displayName}}</h4>
+    </div>
+    <div class="modal-body confirmation-modal">
+      <div class="form-horizontal">
+        <div class="form-group form-inline">
+          <div class="col-md-3 sm-label-right">Current</div>
+          <div class="col-md-3">
+            <div class="input-group">
+              <input
+                type="number"
+                class="form-control input-sm highlight-pristine"
+                ng-model="ctrl.current.desired"
+                readonly
+              />
+              <span class="input-group-addon">pod<span ng-if="ctrl.current.desired !== 1">s</span></span>
+            </div>
+          </div>
+        </div>
+        <div class="form-group form-inline">
+          <div class="col-md-3 sm-label-right">Desired</div>
+          <div class="col-md-3">
+            <div class="input-group">
+              <input
+                type="number"
+                class="form-control input-sm highlight-pristine"
+                ng-model="ctrl.command.capacity.desired"
+                min="0"
+                required
+              />
+              <span class="input-group-addon">pod<span ng-if="ctrl.command.capacity.desired !== 1">s</span></span>
+            </div>
+          </div>
+        </div>
+      </div>
+      <task-reason command="ctrl.command"></task-reason>
+    </div>
+    <div class="modal-footer">
+      <user-verification account="ctrl.serverGroup.account" verification="ctrl.verification"></user-verification>
+      <button type="submit" ng-click="ctrl.resize()" style="display: none"></button>
+      <!-- Allows form submission via enter keypress-->
+      <button class="btn btn-default" ng-click="ctrl.cancel()">Cancel</button>
+      <button
+        type="submit"
+        class="btn btn-primary"
+        ng-click="ctrl.resize()"
+        ng-disabled="!ctrl.isValid() || !resizeForm.$valid"
+      >
+        Submit
+      </button>
+    </div>
+  </form>
+</div>

package/src/serverGroup/index.ts

@@ -0,0 +1,4 @@
+export * from './serverGroupCommandBuilder.service';
+export * from './serverGroupTransformer.service';
+export * from './details/details.controller';
+export * from './details/resize/resize.controller';

package/src/serverGroup/serverGroupCommandBuilder.service.ts

@@ -0,0 +1,18 @@
+import { module } from 'angular';
+
+import type { Application } from '@spinnaker/core';
+import type { IKubernetesManifestCommandData } from '../manifest/manifestCommandBuilder.service';
+import { KubernetesManifestCommandBuilder } from '../manifest/manifestCommandBuilder.service';
+
+export class KubernetesV2ServerGroupCommandBuilder {
+  public buildNewServerGroupCommand(app: Application): PromiseLike<IKubernetesManifestCommandData> {
+    return KubernetesManifestCommandBuilder.buildNewManifestCommand(app);
+  }
+}
+
+export const KUBERNETES_SERVER_GROUP_COMMAND_BUILDER = 'spinnaker.kubernetes.serverGroup.commandBuilder.service';
+
+module(KUBERNETES_SERVER_GROUP_COMMAND_BUILDER, []).service(
+  'kubernetesV2ServerGroupCommandBuilder',
+  KubernetesV2ServerGroupCommandBuilder,
+);

package/src/serverGroup/serverGroupTransformer.service.spec.ts

@@ -0,0 +1,67 @@
+import { Application } from '@spinnaker/core';
+
+import type { IKubernetesServerGroup } from '../interfaces';
+import { KubernetesV2ServerGroupTransformer } from './serverGroupTransformer.service';
+
+describe('KubernetesV2ServerGroupTransformer', function () {
+  it('normalizes server group name', async () => {
+    const transformer = new KubernetesV2ServerGroupTransformer();
+    const ACCOUNT = 'myaccount';
+    const LOCATION = 'myns';
+    const SG_MANAGER = 'sgmanager';
+    const KIND = 'daemonSet';
+
+    const sgMgrRef = { account: ACCOUNT, location: LOCATION, name: SG_MANAGER };
+    const sgAccount = ({
+      account: ACCOUNT,
+      name: 'myservergroup',
+      region: LOCATION,
+      serverGroupManagers: [sgMgrRef],
+    } as unknown) as IKubernetesServerGroup;
+
+    const data = [{ name: `${KIND} ${SG_MANAGER}`, region: LOCATION, account: ACCOUNT, kind: KIND }];
+    const app = new Application('test', null, []);
+    app.getDataSource = () => {
+      return {
+        ready: () => Promise.resolve(data),
+        data,
+      } as any;
+    };
+
+    const sg = await transformer.normalizeServerGroup(sgAccount, app);
+    expect(sg).not.toBe(null);
+    expect(sg.serverGroupManagers.length).toBe(1);
+    expect(sgMgrRef.name).toBe('daemonSet sgmanager');
+  });
+
+  it('does not normalize server group if different account', async () => {
+    const transformer = new KubernetesV2ServerGroupTransformer();
+    const ACCOUNT = 'myaccount';
+    const ACCOUNT2 = 'account2';
+    const LOCATION = 'myns';
+    const SG_MANAGER = 'sgmanager';
+    const KIND = 'daemonSet';
+
+    const sgMgrRef = { account: ACCOUNT, location: LOCATION, name: SG_MANAGER };
+    const sgAccount: IKubernetesServerGroup = ({
+      account: ACCOUNT,
+      name: 'myservergroup',
+      region: LOCATION,
+      serverGroupManagers: [sgMgrRef],
+    } as unknown) as IKubernetesServerGroup;
+
+    const data = [{ name: `${KIND} ${SG_MANAGER}`, region: LOCATION, account: ACCOUNT2, kind: KIND }];
+    const app = new Application('test', null, []);
+    app.getDataSource = () => {
+      return {
+        ready: () => Promise.resolve(data),
+        data,
+      } as any;
+    };
+
+    const sg = await transformer.normalizeServerGroup(sgAccount, app);
+    expect(sg).not.toBe(null);
+    expect(sg.serverGroupManagers.length).toBe(1);
+    expect(sgMgrRef.name).toBe('sgmanager');
+  });
+});

package/src/serverGroup/serverGroupTransformer.service.ts

@@ -0,0 +1,34 @@
+import { module } from 'angular';
+import type { Application } from '@spinnaker/core';
+import type { IKubernetesServerGroup, IKubernetesServerGroupManager } from '../interfaces';
+
+export class KubernetesV2ServerGroupTransformer {
+  public normalizeServerGroup(
+    serverGroup: IKubernetesServerGroup,
+    application: Application,
+  ): PromiseLike<IKubernetesServerGroup> {
+    return application
+      .getDataSource('serverGroupManagers')
+      .ready()
+      .then((sgManagers: IKubernetesServerGroupManager[]) => {
+        (serverGroup.serverGroupManagers || []).forEach((managerRef) => {
+          const sgManager = sgManagers.find(
+            (manager: IKubernetesServerGroupManager) =>
+              managerRef.account == manager.account &&
+              managerRef.location == manager.region &&
+              `${manager.kind} ${managerRef.name}` == manager.name,
+          );
+          if (sgManager) {
+            managerRef.name = sgManager.name;
+          }
+        });
+        return serverGroup;
+      });
+  }
+}
+
+export const KUBERNETES_SERVER_GROUP_TRANSFORMER = 'spinnaker.kubernetes.serverGroup.transformer.service';
+module(KUBERNETES_SERVER_GROUP_TRANSFORMER, []).service(
+  'kubernetesV2ServerGroupTransformer',
+  KubernetesV2ServerGroupTransformer,
+);