Release v0.7.0 (#62)

* release v0.7.0

* add release v0.7.0

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ui-driver-linode",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Rancher UI driver for the Linode docker-machine driver",
   "repository": {
     "type": "git",

releases/v0.7.0/component.css

@@ -0,0 +1,3 @@
+.machine-driver.linode {
+  background-image: url('linode.svg');
+}

releases/v0.7.0/component.js

@@ -0,0 +1,138 @@
+"use strict";
+
+define("nodes/components/driver-linode/component", ["exports", "shared/mixins/node-driver"], function (exports, _nodeDriver) {
+  "use strict";
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  const LAYOUT = "<section class="horizontal-form">
  {{#accordion-list showExpandAll=false as | al expandFn |}}
   {{#if (eq step 1)}}
      {{#accordion-list-item
         title=(t "modalAddCloudKey.linode.token.label")
         detail=(t "modalAddCloudKey.linode.token.help" htmlSafe=true)
         expandAll=expandAll
         expand=(action expandFn)
         expandOnInit=true
      }}
        {{form-auth-cloud-credential
          driverName=driverName
          parseAndCollectErrors=(action "errorHandler")
          primaryResource=primaryResource
          cloudCredentials=cloudCredentials
          finishAndSelectCloudCredential=(action "finishAndSelectCloudCredential")
          progressStep=(action "authLinode")
          cancel=(action "cancel")
          createLabel="modalAddCloudKey.linode.authAccountButton"
        }}
      {{/accordion-list-item}}
    {{top-errors errors=errors}}
  {{else}}
  {{#accordion-list showExpandAll=false as | al expandFn |}}
    {{!-- This line shows the driver title which you don't have to change it --}}
    <div class="over-hr"><span>{{driverOptionsTitle}}</span></div>
      {{#accordion-list-item
        title="Instance Options"
        detail="Configure the options for the Linode Instances that will be created by this template."
        expandAll=expandAll
        expand=(action expandFn)
        expandOnInit=true
      }}
      {{!-- Start of Linode Options --}}
        <div class="row">
          <div class="col span-6">
            <label class="acc-label">Region</label>
            <select class="form-control" onchange={{action (mut model.linodeConfig.region) value="target.value" }}>
              {{#each regionChoices as |choice|}}
                <option value={{choice.id}} selected={{eq model.linodeConfig.region choice.id}}>{{choice.label}}</option>
              {{/each}}
            </select>
          </div>

          <div class="col span-6">
            <label class="acc-label">Instance Type</label>
            <select class="form-control" onchange={{action (mut model.linodeConfig.instanceType) value="target.value" }}>
              {{#each sizeChoices as |choice|}}
                <option value={{choice.id}} selected={{eq model.linodeConfig.instanceType choice.id}}>{{choice.label}} - {{choice.vcpus}} vCPUs, {{choice.memory}}GB Memory, {{choice.disk}}GB Disk space</option>
              {{/each}}
            </select>
          </div>
        </div>
        <div class="row">
          <div class="col span-6">
            <label class="acc-label">Image</label>
            <select class="form-control" onchange={{action (mut model.linodeConfig.image) value="target.value" }}>
              {{#each imageChoices as |choice|}}
                <option value={{choice.id}} selected={{eq model.linodeConfig.image choice.id}}>{{choice.label}}</option>
              {{/each}}
            </select>
          </div>
          {{#unless profile.restricted }}
            <div class="col span-6">
              <label class="acc-label">Tags</label>
              {{ input classNames="form-control" placeholder="Examples: tagA, tagB, tagC" value=model.linodeConfig.tags }}
            </div>
          {{/unless}}
        </div>
        <div class="row">
          <div class="col span-6">
            <label class="acc-label">Private IP</label>
            <div class="checkbox">
              <label class="acc-label">{{input type="checkbox" checked=model.linodeConfig.createPrivateIp}} Add a Private IP</label>
            </div>
          </div>
        </div>
      {{/accordion-list-item}}
      {{!-- End of Linode Options --}}
      {{#accordion-list-item
        title="Authentication"
        detail="Configure Linode user SSH Keys and a password for the 'root' user account"
        expandAll=expandAll
        expand=(action expandFn)
        expandOnInit=false
      }}
        <div class="row">
          <div class="col span-12">
            <label class="acc-label">Password for the "root" user</label>
            {{ input
              type="password"
              classNames="form-control"
              value=model.linodeConfig.rootPass
              placeholder="aComplexP@ssword"
            }}
          </div>
          <div class="col span-12">
            <label class="acc-label">Linode Usernames</label>
            {{ input classNames="form-control" placeholder="yourusername" value=model.linodeConfig.authorizedUsers }}
          </div>
        </div>
      {{/accordion-list-item}}
      {{#accordion-list-item
        title="StackScripts"
        detail="Configure a StackScript to run on first boot"
        expandAll=expandAll
        expand=(action expandFn)
        expandOnInit=false
      }}
        <div class="row">
          <div class="col span-12">
            <label class="acc-label">StackScript (<a href="https://cloud.linode.com/stackscripts" target="_blank" rel="nofollow noreferrer noopener">manage your StackScripts</a>)</label>
            {{ input
            classNames="form-control"
            placeholder="Examples: 'username/Stackscript Label' or '12345'"
            value=model.linodeConfig.stackscript
            }}
          </div>
          <div class="col span-12">
            <label class="acc-label">StackScript Variables</label>
            {{ textarea classNames="form-control" placeholder='{ "example": "value", "json": true }' value=model.linodeConfig.stackscriptData }}
          </div>
        </div>
      {{/accordion-list-item}}
      {{!-- End of Linode Options --}}

    {{!-- This following contains the Name, Labels and Engine Options fields --}}
    <div class="over-hr"><span>{{templateOptionsTitle}}</span></div>

    {{form-name-description
      model=model
      nameRequired=true
    }}

    {{form-user-labels
      initialLabels=labelResource.labels
      setLabels=(action 'setLabels')
      expandAll=expandAll
      expand=(action expandFn)
    }}

    {{form-engine-opts
      machine=model
      showEngineUrl=showEngineUrl
    }}
  {{/accordion-list}}


  {{!-- This component shows errors produced by validate() in the component --}}
  {{top-errors errors=errors}}

  {{!-- This component shows the Create and Cancel buttons --}}
  {{save-cancel save=(action "save") editing=editing cancel=(action "cancel")}}
  {{/if}}
  {{/accordion-list}}
</section>
";
+  const computed = Ember.computed;
+  const get = Ember.get;
+  const set = Ember.set;
+  const alias = Ember.computed.alias;
+  const service = Ember.inject.service;
+  const observer = Ember.observer;
+  const hash = Ember.RSVP.hash;
+  const defaultRadix = 10;
+  const defaultBase = 1024;
+  exports.default = Ember.Component.extend(_nodeDriver.default, {
+    driverName: 'linode',
+    step: 1,
+    config: alias('model.linodeConfig'),
+    app: service(),
+    intl: service(),
+    linode: service(),
+    init() {
+      const decodedLayout = window.atob(LAYOUT);
+      const template = Ember.HTMLBars.compile(decodedLayout, {
+        moduleName: 'nodes/components/driver-linode/template'
+      });
+      set(this, 'layout', template);
+      this._super(...arguments);
+    },
+    bootstrap: function () {
+      let config = get(this, 'globalStore').createRecord({
+        type: 'linodeConfig',
+        instanceType: 'g6-standard-4',
+        region: 'us-iad',
+        image: 'linode/ubuntu22.04',
+        uaPrefix: 'Rancher',
+        tags: '',
+        authorizedUsers: '',
+        createPrivateIp: true,
+        stackscript: '',
+        stackscriptData: '',
+        rootPass: null
+      });
+      set(this, 'model.linodeConfig', config);
+    },
+    validate() {
+      this._super();
+      var errors = get(this, 'errors') || [];
+      if (!get(this, 'model.name')) {
+        errors.push('Name is required');
+      }
+      if (!this.get('model.linodeConfig.instanceType')) {
+        errors.push('Specifying a linode Instance Type is required');
+      }
+      if (!this.get('model.linodeConfig.image')) {
+        errors.push('Specifying a linode Image is required');
+      }
+      if (!this.get('model.linodeConfig.region')) {
+        errors.push('Specifying a linode Region is required');
+      }
+      if (!this.validateCloudCredentials()) {
+        errors.push(this.intl.t('nodeDriver.cloudCredentialError'));
+      }
+      if (get(errors, 'length')) {
+        set(this, 'errors', errors);
+        return false;
+      } else {
+        set(this, 'errors', null);
+        return true;
+      }
+    },
+    actions: {
+      finishAndSelectCloudCredential(cred) {
+        if (cred) {
+          set(this, 'model.cloudCredentialId', get(cred, 'id'));
+          this.send('authLinode');
+        }
+      },
+      authLinode(cb) {
+        const auth = {
+          type: 'cloud',
+          token: get(this, 'model.cloudCredentialId')
+        };
+        hash({
+          regions: this.linode.request(auth, 'regions'),
+          images: this.linode.request(auth, 'images'),
+          sizes: this.linode.request(auth, 'linode/types')
+        }).then(responses => {
+          this.setProperties({
+            errors: [],
+            step: 2,
+            restricted: responses.regions.restricted,
+            regionChoices: responses.regions.data.map(region => {
+              region.label = region.id.slice(0, 4).toUpperCase() + region.id.slice(4) + " (" + region.country.toUpperCase() + ")";
+              return region;
+            }).sort((a, b) => String.prototype.localeCompare(a, b)),
+            imageChoices: responses.images.data.filter(image => /^linode.(ubuntu22.04|ubuntu20.04|ubuntu18.04|ubuntu16.04|debian10|debian9)/.test(image.id) && !image.id.includes('kube')).sort((a, b) => a.id > b.id),
+            sizeChoices: responses.sizes.data.map(size => {
+              size.disk /= 1024;
+              size.memory /= 1024;
+              return size;
+            })
+          });
+        }).catch(err => {
+          let errors = get(this, 'errors') || [];
+          if (err && err.body && err.body.errors && err.body.errors[0]) {
+            errors.push(`Error received from Linode: ${err.body.errors[0].reason}`);
+          } else {
+            errors.push(`Error received from Linode`);
+          }
+          this.setProperties({
+            errors
+          });
+          cb();
+        });
+      }
+    }
+  });
+});;
+"use strict";
+
+define("ui/components/driver-linode/component", ["exports", "nodes/components/driver-linode/component"], function (exports, _component) {
+  "use strict";
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function () {
+      return _component.default;
+    }
+  });
+});