first commit

batch/models/query/fallback.js

@@ -0,0 +1,78 @@
+'use strict';
+
+var util = require('util');
+var QueryBase = require('./query_base');
+var jobStatus = require('../../job_status');
+
+function Fallback(index) {
+    QueryBase.call(this, index);
+}
+util.inherits(Fallback, QueryBase);
+
+module.exports = Fallback;
+
+Fallback.is = function (query) {
+    if (query.onsuccess || query.onerror) {
+        return true;
+    }
+    return false;
+};
+
+Fallback.prototype.getNextQuery = function (job) {
+    if (this.hasOnSuccess(job)) {
+        return this.getOnSuccess(job);
+    }
+    if (this.hasOnError(job)) {
+        return this.getOnError(job);
+    }
+};
+
+Fallback.prototype.getOnSuccess = function (job) {
+    if (job.query.query[this.index].status === jobStatus.DONE &&
+        job.query.query[this.index].fallback_status === jobStatus.PENDING) {
+        var onsuccessQuery = job.query.query[this.index].onsuccess;
+        if (onsuccessQuery) {
+            onsuccessQuery = onsuccessQuery.replace(/<%=\s*job_id\s*%>/g, job.job_id);
+        }
+        return onsuccessQuery;
+    }
+};
+
+Fallback.prototype.hasOnSuccess = function (job) {
+    return !!this.getOnSuccess(job);
+};
+
+Fallback.prototype.getOnError = function (job) {
+    if (job.query.query[this.index].status === jobStatus.FAILED &&
+        job.query.query[this.index].fallback_status === jobStatus.PENDING) {
+        var onerrorQuery = job.query.query[this.index].onerror;
+        if (onerrorQuery) {
+            onerrorQuery = onerrorQuery.replace(/<%=\s*job_id\s*%>/g, job.job_id);
+            onerrorQuery = onerrorQuery.replace(/<%=\s*error_message\s*%>/g, job.query.query[this.index].failed_reason);
+        }
+        return onerrorQuery;
+    }
+};
+
+Fallback.prototype.hasOnError = function (job) {
+    return !!this.getOnError(job);
+};
+
+Fallback.prototype.setStatus = function (status, job, errorMessage) {
+    var isValid = false;
+
+    isValid = this.isValidTransition(job.query.query[this.index].fallback_status, status);
+
+    if (isValid) {
+        job.query.query[this.index].fallback_status = status;
+        if (status === jobStatus.FAILED && errorMessage) {
+            job.query.query[this.index].failed_reason = errorMessage;
+        }
+    }
+
+    return isValid;
+};
+
+Fallback.prototype.getStatus = function (job) {
+    return job.query.query[this.index].fallback_status;
+};

batch/models/query/main_fallback.js

@@ -0,0 +1,74 @@
+'use strict';
+
+var util = require('util');
+var QueryBase = require('./query_base');
+var jobStatus = require('../../job_status');
+
+function MainFallback() {
+    QueryBase.call(this);
+}
+util.inherits(MainFallback, QueryBase);
+
+module.exports = MainFallback;
+
+MainFallback.is = function (job) {
+    if (job.query.onsuccess || job.query.onerror) {
+        return true;
+    }
+    return false;
+};
+
+MainFallback.prototype.getNextQuery = function (job) {
+    if (this.hasOnSuccess(job)) {
+        return this.getOnSuccess(job);
+    }
+
+    if (this.hasOnError(job)) {
+        return this.getOnError(job);
+    }
+};
+
+MainFallback.prototype.getOnSuccess = function (job) {
+    if (job.status === jobStatus.DONE && job.fallback_status === jobStatus.PENDING) {
+        return job.query.onsuccess;
+    }
+};
+
+MainFallback.prototype.hasOnSuccess = function (job) {
+    return !!this.getOnSuccess(job);
+};
+
+MainFallback.prototype.getOnError = function (job) {
+    if (job.status === jobStatus.FAILED && job.fallback_status === jobStatus.PENDING) {
+        return job.query.onerror;
+    }
+};
+
+MainFallback.prototype.hasOnError = function (job) {
+    return !!this.getOnError(job);
+};
+
+MainFallback.prototype.setStatus = function (status, job, previous) {
+    var isValid = false;
+    var appliedToFallback = false;
+
+    if (previous.isValid && !previous.appliedToFallback) {
+        if (this.isFinalStatus(status) && !this.hasNextQuery(job)) {
+            isValid = this.isValidTransition(job.fallback_status, jobStatus.SKIPPED);
+
+            if (isValid) {
+                job.fallback_status = jobStatus.SKIPPED;
+                appliedToFallback = true;
+            }
+        }
+    } else if (!previous.isValid) {
+        isValid = this.isValidTransition(job.fallback_status, status);
+
+        if (isValid) {
+            job.fallback_status = status;
+            appliedToFallback = true;
+        }
+    }
+
+    return { isValid: isValid, appliedToFallback: appliedToFallback };
+};

batch/models/query/query.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var util = require('util');
+var QueryBase = require('./query_base');
+var jobStatus = require('../../job_status');
+
+function Query(index) {
+    QueryBase.call(this, index);
+}
+util.inherits(Query, QueryBase);
+
+module.exports = Query;
+
+Query.is = function (query) {
+    if (query.query && typeof query.query === 'string') {
+        return true;
+    }
+
+    return false;
+};
+
+Query.prototype.getNextQuery = function (job) {
+    if (job.query.query[this.index].status === jobStatus.PENDING) {
+        var query = {
+            query: job.query.query[this.index].query
+        };
+        if (Number.isFinite(job.query.query[this.index].timeout)) {
+            query.timeout = job.query.query[this.index].timeout;
+        }
+        return query;
+    }
+};
+
+Query.prototype.setStatus = function (status, job, errorMesssage) {
+    var isValid = false;
+
+    isValid = this.isValidTransition(job.query.query[this.index].status, status);
+
+    if (isValid) {
+        job.query.query[this.index].status = status;
+        if (status === jobStatus.RUNNING) {
+            job.query.query[this.index].started_at = new Date().toISOString();
+        }
+        if (this.isFinalStatus(status)) {
+            job.query.query[this.index].ended_at = new Date().toISOString();
+        }
+        if (status === jobStatus.FAILED && errorMesssage) {
+            job.query.query[this.index].failed_reason = errorMesssage;
+        }
+    }
+
+    return isValid;
+};
+
+Query.prototype.getStatus = function (job) {
+    return job.query.query[this.index].status;
+};

batch/models/query/query_base.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var util = require('util');
+var JobStateMachine = require('../job_state_machine');
+
+function QueryBase(index) {
+    JobStateMachine.call(this);
+
+    this.index = index;
+}
+util.inherits(QueryBase, JobStateMachine);
+
+module.exports = QueryBase;
+
+// should be implemented
+QueryBase.prototype.setStatus = function () {
+    throw new Error('Unimplemented method');
+};
+
+// should be implemented
+QueryBase.prototype.getNextQuery = function () {
+    throw new Error('Unimplemented method');
+};
+
+QueryBase.prototype.hasNextQuery = function (job) {
+    return !!this.getNextQuery(job);
+};
+
+QueryBase.prototype.getStatus = function () {
+    throw new Error('Unimplemented method');
+};

batch/models/query/query_factory.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var QueryFallback = require('./query_fallback');
+
+function QueryFactory() {
+}
+
+module.exports = QueryFactory;
+
+QueryFactory.create = function (job, index) {
+    if (QueryFallback.is(job.query.query[index])) {
+        return new QueryFallback(job, index);
+    }
+
+    throw new Error('there is no query class for the provided query');
+};

batch/models/query/query_fallback.js

@@ -0,0 +1,75 @@
+'use strict';
+
+var util = require('util');
+var QueryBase = require('./query_base');
+var Query = require('./query');
+var Fallback = require('./fallback');
+var jobStatus = require('../../job_status');
+
+function QueryFallback(job, index) {
+    QueryBase.call(this, index);
+
+    this.init(job, index);
+}
+
+util.inherits(QueryFallback, QueryBase);
+
+QueryFallback.is = function (query) {
+    if (Query.is(query)) {
+        return true;
+    }
+    return false;
+};
+
+QueryFallback.prototype.init = function (job, index) {
+    this.query = new Query(index);
+
+    if (Fallback.is(job.query.query[index])) {
+        this.fallback = new Fallback(index);
+    }
+};
+
+QueryFallback.prototype.getNextQuery = function (job) {
+    if (this.query.hasNextQuery(job)) {
+        return this.query.getNextQuery(job);
+    }
+
+    if (this.fallback && this.fallback.hasNextQuery(job)) {
+        return this.fallback.getNextQuery(job);
+    }
+};
+
+QueryFallback.prototype.setStatus = function (status, job, previous, errorMesssage) {
+    // jshint maxcomplexity: 9
+    var isValid = false;
+    var appliedToFallback = false;
+
+    if (previous.isValid && !previous.appliedToFallback) {
+        if (status === jobStatus.FAILED || status === jobStatus.CANCELLED) {
+            this.query.setStatus(jobStatus.SKIPPED, job, errorMesssage);
+
+            if (this.fallback) {
+                this.fallback.setStatus(jobStatus.SKIPPED, job);
+            }
+        }
+    } else if (!previous.isValid) {
+        isValid = this.query.setStatus(status, job, errorMesssage);
+
+        if (this.fallback) {
+            if (!isValid) {
+                isValid = this.fallback.setStatus(status, job, errorMesssage);
+                appliedToFallback = true;
+            } else if (isValid && this.isFinalStatus(status) && !this.fallback.hasNextQuery(job)) {
+                this.fallback.setStatus(jobStatus.SKIPPED, job);
+            }
+        }
+    }
+
+    return { isValid: isValid, appliedToFallback: appliedToFallback };
+};
+
+QueryFallback.prototype.getStatus = function (job) {
+    return this.query.getStatus(job);
+};
+
+module.exports = QueryFallback;