Merge pull request #1 from AcalephStorage/feature/gh-login

Minimal Dashboard (w/ Github login)

Author: darkcrux

.gitignore

@@ -15,3 +15,4 @@
 /libpeerconnection.log
 npm-debug.log
 testem.log
+/.env

.jshintrc

@@ -2,7 +2,8 @@
   "predef": [
     "document",
     "window",
-    "-Promise"
+    "-Promise",
+    "moment"
   ],
   "browser": true,
   "boss": true,

.watchmanconfig

@@ -1,3 +1,3 @@
 {
-  "ignore_dirs": ["tmp"]
+  "ignore_dirs": ["tmp", "dist"]
 }

Caddyfile

@@ -0,0 +1,10 @@
+0.0.0.0:5000 {
+  gzip
+  root /home/apps/kontinuous-ui/dist
+  rewrite / {
+    regexp .*
+    ext    /
+    to     /index.html
+}
+  log stdout
+}

Dockerfile

@@ -0,0 +1,23 @@
+FROM node:0.12.7
+
+# Install ember, bower, forego, and caddy
+RUN npm install -g [email protected] && \
+    npm install -g [email protected]  && \
+    wget https://bin.equinox.io/c/ekMN3bCZFUn/forego-stable-linux-amd64.tgz -O /tmp/forego.tar.gz && \
+    tar xvz -C /usr/local/bin -f /tmp/forego.tar.gz && \
+    rm /tmp/forego.tar.gz && \
+    chmod 0744 /usr/local/bin/forego && \
+    wget https://github.com/mholt/caddy/releases/download/v0.7.6/caddy_linux_amd64.tar.gz -O /tmp/caddy.tar.gz && \
+    tar xvz -C /usr/local/bin -f /tmp/caddy.tar.gz && \
+    rm /tmp/caddy.tar.gz
+
+ADD . /home/apps/kontinuous-ui
+WORKDIR /home/apps/kontinuous-ui
+
+RUN npm install && \
+    bower install --allow-root
+ENV KUBERNETES_API_URL kubernetes.default
+ENV KUBERNETES_API_TOKEN_PATH /run/secrets/kubernetes.io/serviceaccount/token
+ENV KUBERNETES_API_TOKEN token
+
+CMD ["/usr/local/bin/forego", "start", "-f", "config/Procfile", "-p", "5000"]

app/adapters/application.js

@@ -0,0 +1,55 @@
+import DS from 'ember-data';
+import DataAdapterMixin from 'ember-simple-auth/mixins/data-adapter-mixin';
+import Configuration from '../config/environment';
+import Ember from 'ember';
+
+export default DS.RESTAdapter.extend(DataAdapterMixin, {
+
+  authorizer: 'authorizer:kontinuous',
+  defaultSerializer: 'kontinuous',
+  host: Configuration.APP.kontinuousAPI.host,
+  namespace: `api/${Configuration.APP.kontinuousAPI.version}`,
+
+  handleResponse(status, headers, payload) {
+    if (payload && payload.hasOwnProperty('Code') && (payload.Code >= 400 && payload.Code <= 500)) {
+      return new DS.AdapterError(payload);
+    }
+    return this._super(...arguments);
+  },
+
+
+  queryRecord(store, type, query) {
+    var q = Ember.copy(query),
+        url = this.buildURL(type.modelName, null, null, "queryRecord", q);
+
+    if (this.sortQueryParams) {
+      q = this.sortQueryParams(q);
+    }
+
+    return this.ajax(url, "GET", { data: q });
+  },
+
+  query(store, type, query) {
+    var q = Ember.copy(query),
+        url = this.buildURL(type.modelName, null, null, "query", q);
+
+    if (this.sortQueryParams) {
+      q = this.sortQueryParams(q);
+    }
+
+    return this.ajax(url, "GET", { data: q });
+  },
+
+  urlForQueryRecord: function(query, modelName) {
+    var urlParts = this._buildURL(modelName).split('/');
+
+    if (Ember.isPresent(query.owner) && Ember.isPresent(query.repo)) {
+      urlParts.push(query.owner, query.repo);
+      delete query.owner;
+      delete query.repo;
+    }
+
+    return urlParts.join('/');
+  },
+
+});

app/adapters/build.js

@@ -0,0 +1,40 @@
+import ApplicationAdapter from './application';
+import DS from 'ember-data';
+import Ember from 'ember';
+
+export default ApplicationAdapter.extend({
+
+  createRecord: function (store, type, snapshot) {
+    var pipeline = snapshot.record.get('pipeline');
+    if (Ember.isNone(pipeline)) {
+      return new DS.AdapterError();
+    }
+    var data = {},
+        url = this.buildURL(type.modelName, null, snapshot, 'createRecord');
+
+    var serializer = store.serializerFor(type.modelName);
+    serializer.serializeIntoHash(data, type, snapshot, { includeId: false });
+
+    delete data.stages;
+
+    return this.ajax(url, 'POST', {
+      headers: {'X-Custom-Event': 'dashboard'},
+      data: data,
+    });
+  },
+
+  urlForCreateRecord(modelName, snapshot) {
+    var urlParts = this._buildURL(modelName).split('/');
+    urlParts.removeObject(this.pathForType(modelName));
+
+    var owner = snapshot.record.get('pipeline.owner'),
+        repo = snapshot.record.get('pipeline.repo');
+
+    if (Ember.isPresent(owner) && Ember.isPresent(repo)) {
+      urlParts.push('pipelines', owner, repo);
+    }
+
+    urlParts.push(this.pathForType(modelName));
+    return urlParts.join('/');
+  }
+});

app/adapters/k8s-log.js

@@ -0,0 +1,36 @@
+import Ember from 'ember';
+import K8sAdapter from './k8s';
+
+export default K8sAdapter.extend({
+
+  defaultSerializer: 'k8s-log',
+
+  pathForType() {
+    return 'log';
+  },
+
+  queryRecord(store, type, _data) {
+    let data = Ember.copy(_data);
+
+    var urlParts = this.buildURL(type.modelName, null, null, "query", data).split('/');
+    urlParts.removeObject(this.pathForType());
+
+    if (Ember.isPresent(data.namespace) && Ember.isPresent(data.podName)) {
+      urlParts.push('namespaces', data.namespace);
+      urlParts.push('pods', data.podName);
+      delete data.namespace;
+      delete data.podName;
+    }
+
+    urlParts.push(this.pathForType());
+    let url = urlParts.join('/');
+    return this.ajax(url, "GET", { data: data });
+  },
+
+  ajaxOptions() {
+    var hash = this._super.apply(this, arguments);
+    hash.dataType = "text";
+    return hash;
+  }
+
+});

app/adapters/k8s.js

@@ -0,0 +1,52 @@
+import RESTAdapter from 'ember-data/adapters/rest';
+import DataAdapterMixin from 'ember-simple-auth/mixins/data-adapter-mixin';
+import Configuration from '../config/environment';
+import Ember from 'ember';
+import DS from 'ember-data';
+
+export default RESTAdapter.extend(DataAdapterMixin, {
+
+  authorizer: 'authorizer:k8s',
+  defaultSerializer: 'k8s',
+  host: Configuration.APP.k8sAPI.host,
+  namespace: `api/${Configuration.APP.k8sAPI.version}`,
+
+  pathForType(modelName) {
+    var trimmed = modelName.replace(/^k8s-+/, '');
+    return trimmed.pluralize();
+  },
+
+  _setNamespace(type, snapshot) {
+    var namespace = this.get('namespace');
+
+    if (type.modelName !== 'namespace') {
+      this.set('namespace', namespace + '/namespaces/' + this.serialize(snapshot).metadata.namespace);
+    }
+
+    return namespace;
+  },
+
+  queryRecord(store, type, _data) {
+    let data = Ember.copy(_data);
+    let path = this.pathForType(type.modelName);
+    let urlParts = this.buildURL(type.modelName, null, null, path, data).split('/');
+    urlParts.removeObject(path);
+
+    if (Ember.isPresent(data.namespace) && Ember.isPresent(data.name)) {
+      urlParts.push('namespaces', data.namespace);
+      urlParts.push(path, data.name);
+      delete data.namespace;
+      delete data.name;
+    }
+
+    let url = urlParts.join('/');
+    return this.ajax(url, "GET", { data: data });
+  },
+
+  handleResponse(status, headers, payload) {
+    if (payload.hasOwnProperty('kind') && payload.kind === 'Status' && (payload.code >= 400 && payload.code <= 500)) {
+      return new DS.AdapterError(payload);
+    }
+    return this._super(...arguments);
+  }
+});

app/adapters/pod.js

@@ -0,0 +1,3 @@
+import K8sAdapter from './k8s';
+
+export default K8sAdapter.extend();

app/adapters/stage.js

@@ -0,0 +1,26 @@
+import ApplicationAdapter from './application';
+import Ember from 'ember';
+
+export default ApplicationAdapter.extend({
+
+  _getLogs(query) {
+    let q = Ember.copy(query);
+    let urlParts = this.urlForQueryRecord(q).split('/');
+    urlParts.push('logs');
+    let url = urlParts.join('/');
+    return this.ajax(url, 'GET', {data: q});
+  },
+
+  urlForQueryRecord: function(query, modelName) {
+    var urlParts = this._buildURL(modelName).split('/');
+
+    if (Ember.isPresent(query.owner) && Ember.isPresent(query.repo) && Ember.isPresent(query.buildNumber) && Ember.isPresent(query.stageIndex)) {
+      urlParts.push('pipelines', query.owner, query.repo, 'builds', query.buildNumber, 'stages', query.stageIndex);
+      delete query.owner;
+      delete query.repo;
+      delete query.buildNumber;
+      delete query.stageIndex;
+    }
+    return urlParts.join('/');
+  },
+});

app/authenticators/k8s.js

@@ -0,0 +1,44 @@
+import Ember from 'ember';
+import BaseAuthenticator from 'ember-simple-auth/authenticators/base';
+import config from '../config/environment';
+
+export default BaseAuthenticator.extend({
+
+  tokenEndpoint: config.APP.k8sAPI.host + '/sessions/create',
+
+  restore(data) {
+    return new Ember.RSVP.Promise((resolve, reject) => {
+      if (Ember.isEmpty(data.token)) {
+        resolve(data);
+      } else {
+        reject();
+      }
+    });
+  },
+
+  authenticate(options) {
+    return new Ember.RSVP.Promise((resolve, reject) => {
+      Ember.$.ajax({
+        url: this.tokenEndpoint,
+        type: 'POST',
+        data: JSON.stringify({
+          username: options.username,
+          password: options.password
+        }),
+      })
+      .then((response) => {
+        Ember.run(() => {
+          resolve({token: response.id_token});
+        });
+      }, (xhr) => {
+        Ember.run(() => {
+          reject(xhr.responseText);
+        });
+      });
+    });
+  },
+
+  invalidate() {
+    return Ember.RSVP.resolve();
+  }
+});

app/authenticators/kontinuous.js

@@ -0,0 +1,6 @@
+import Ember from 'ember';
+import ToriiAuthenticator from 'ember-simple-auth/authenticators/torii';
+
+export default ToriiAuthenticator.extend({
+  torii: Ember.inject.service()
+});

app/authorizers/k8s.js

@@ -0,0 +1,15 @@
+import Ember from 'ember';
+import BaseAuthorizer from 'ember-simple-auth/authorizers/base';
+
+const {isEmpty} = Ember;
+
+export default BaseAuthorizer.extend({
+
+  authorize(sessionData, block) {
+    const token = sessionData.jwt;
+    if (!isEmpty(token)) {
+      block('Authorization', `Bearer ${token}`);
+    }
+  }
+
+});

app/authorizers/kontinuous.js

@@ -0,0 +1,15 @@
+import Ember from 'ember';
+import BaseAuthorizer from 'ember-simple-auth/authorizers/base';
+
+const {isEmpty} = Ember;
+
+export default BaseAuthorizer.extend({
+
+  authorize(sessionData, block) {
+    const token = sessionData.jwt;
+    if (!isEmpty(token)) {
+      block('Authorization', `Bearer ${token}`);
+    }
+  }
+
+});