export function main({RN, HTTP}) {
let requestStars$ = Rx.Observable.just({url: REPO_URL});
let requestEvents$ = Rx.Observable.just({url: COLL_URL});
let request$ = Rx.Observable.merge(requestStars$, requestEvents$);
return {
RN: model(intent(RN, HTTP)).map(view),
HTTP: request$
};
}
function model({increment, starsResponse, eventsResponse, chilicornState, goToSecondView, goToThirdView, goToCreditsView, back}) {
// Initial state
const initialNavigationState = {
key: 'MainNavigation',
index: 0,
title: 'Cycle Native',
children: [
{key: 'Counter'}
]
};
const counter = increment
.startWith(0)
.scan((state, n) => state + n);
const selectedProfile = goToSecondView
.startWith({data: {}})
.map(({data}) => data);
const navigationState = Rx.Observable.merge(
goToSecondView,
goToThirdView,
goToCreditsView,
back
)
.distinctUntilChanged(navigationState => navigationState, (a, b) => {
if (a.type === `back` && b.type === `back`) {
return false
}
return a.key === b.key
})
.startWith(initialNavigationState)
.scan((prevState, action) => {
return action.type === 'back'
? NavigationStateUtils.pop(prevState)
: NavigationStateUtils.push(prevState, action)
})
return Rx.Observable.combineLatest(counter, chilicornState, starsResponse, eventsResponse, navigationState, selectedProfile,
(counter, chilicornState, starsResponse, eventsResponse, navigationState, selectedProfile) => ({
counter,
chilicornState,
starsResponse,
eventsResponse,
navigationState,
selectedProfile
}));
}
self.workingSet.addToSet(workItem, function(err, result) {
if (!err){
// dispatch to the worker
// workers get only the information they need
workItem.startTime = Date.now();
var workObj = {work: workItem.work,
callback:callbackWithTimeout(completeCallbackFn(self,
workItem,
function() {
workInFlight--;
Rx.Observable.Start(getNextWork);}
), self.workTimeout)};
// catch any work exception
try {
obs.OnNext(workObj);
} catch (exn){
// set the exception and mark the work complete
workObj.callback(exn, null);
// Rx next tick self schedule
Rx.Observable.Start(getNextWork);
}
} else {
// fail the worker
obs.OnError(err);
}
});
Qrx.prototype.completedObservable = function() {
var self = this;
var rc = newRedisClient(this.redisOptions);
var pending = new WorkQueue(this.completedQueueName, this.redisOptions);
return Rx.Observable.Create(function(obs) {
function getNextCompleted() {
while(self.completedInFlight < self.completedThrottle){
self.completedInFlight++
pending.blockingDequeue(rc, 0, function(err, completedWorkItem){
if (!err){
obs.OnNext(completedWorkItem);
self.completedInFlight--;
if (!self.queueStopped){
Rx.Observable.Start(getNextCompleted);
} else {
obs.OnCompleted();
}
} else {
obs.OnError(err);
}
});
}
}
Rx.Observable.Start(getNextCompleted);
return function(){rc.quit();};
});
};
Qrx.prototype.initialize = function (options) {
options = options || {};
_.defaults(options, {qname: uuid.v1(), // default unique q name
redisOptions: null, // local host default
workTimeout: Number.MAX_VALUE,
workThrottle: 1,
completedThrottle: 1});
_.extend(this, options);
this.completedInFlight = 0;
// two clients are required to avoid blocking conditions
this.client = newRedisClient(options.redisOptions);
// every q get's a unique id
this.clientId = uuid.v1();
this.pending = new WorkQueue(ns(this.qname, 'pending'), this.redisOptions);
this.workingSet = new WorkSet(ns(this.qname, 'working'), this.redisOptions);
// all work enqueued by the client, is return to this client
this.completedQueueName = ns(this.qname, 'completed') + this.clientId;
// global redis count of workers on this queue
this.workerCount = ns(this.qname, 'worker-count');
this.STOP_MESSAGE = "QRX_STOP_QUEUE"
this.queueStopped = false;
this.statsChannel = new Channel({name:this.qname, redisOptions:options.redisOptions});
// setup stat counters
this.stats = {
pendingWorkCount:0,
completedWorkCount:0,
avgWorkTime:0,
completedWorkBytes:0,
errorCount:0,
lastError:null,
workerId:this.clientId,
workerHost:os.hostname()
};
// start the stats heartbeat
var self = this;
this.statsHeartbeat = Rx.Observable.Interval(1000).Subscribe(function(tick) {
self.statsChannel.send(self.stats);
});
}
function loadData(file, d3Loader) {
return Rx.Observable.create(observer => {
d3Loader(file, (error, data) => {
if (error) {
observer.onError(error);
}
observer.onNext(data);
observer.onCompleted();
});
});
}
pending.blockingDequeue(rc, 0, function(err, completedWorkItem){
if (!err){
obs.OnNext(completedWorkItem);
self.completedInFlight--;
if (!self.queueStopped){
Rx.Observable.Start(getNextCompleted);
} else {
obs.OnCompleted();
}
} else {
obs.OnError(err);
}
});
return Rx.Observable.Create(function(obs) {
function getNextWork(){
// this will set n callbacks where n == throttle
while (workInFlight < self.workThrottle){
workInFlight++;
self.pending.blockingDequeue(rc, 0, function(err, workItem) {
if (workItem.work != this.STOP_MESSAGE) {
// add it to the working set
self.workingSet.addToSet(workItem, function(err, result) {
if (!err){
// dispatch to the worker
// workers get only the information they need
workItem.startTime = Date.now();
var workObj = {work: workItem.work,
callback:callbackWithTimeout(completeCallbackFn(self,
workItem,
function() {
workInFlight--;
Rx.Observable.Start(getNextWork);}
), self.workTimeout)};
// catch any work exception
try {
obs.OnNext(workObj);
} catch (exn){
// set the exception and mark the work complete
workObj.callback(exn, null);
// Rx next tick self schedule
Rx.Observable.Start(getNextWork);
}
} else {
// fail the worker
obs.OnError(err);
}
});
} else {
// signal worker complete
obs.OnCompleted();
}
});
}
}
// initial kick-off
Rx.Observable.Start(getNextWork);
return function(){rc.quit();};
});
this.dequeueRx = function() {
var self = this;
return Rx.Observable.Create(function(obs){
self.dequeue(function(err, item){
if (!err){
if (item){
obs.OnNext(item);
}
// complete with no next is empty
obs.OnCompleted();
} else {
obs.OnError(err);
}
});
return function(){};
});
}
return Rx.Observable.Create(function(obs) {
function getNextCompleted() {
while(self.completedInFlight < self.completedThrottle){
self.completedInFlight++
pending.blockingDequeue(rc, 0, function(err, completedWorkItem){
if (!err){
obs.OnNext(completedWorkItem);
self.completedInFlight--;
if (!self.queueStopped){
Rx.Observable.Start(getNextCompleted);
} else {
obs.OnCompleted();
}
} else {
obs.OnError(err);
}
});
}
}
Rx.Observable.Start(getNextCompleted);
return function(){rc.quit();};
});
Qrx.prototype.statsObservable = function(period) {
// returns the rolled-up stats for the Qrx cluster
period = period || 3000;
// dictionary of cluster stats updates by workingId
var qrxStats = {};
var updateCount = 0;
// subscribe to the stats channel for every worker
var statsSubs = this.statsChannel.subscribe(function(statsUpdate){
function updateSummary(running, nextUpdate) {
updateCount++;
running.totalPendingWorkCount += nextUpdate.pendingWorkCount;
running.totalCompletedWorkCount += nextUpdate.completedWorkCount;
running.totalErrorCount += nextUpdate.errorCount;
running.totalErrorRate = running.totalErrorCount/running.totalCompletedWorkCount;
running.totalCompletedWorkBytes += nextUpdate.completedWorkBytes;
running.totalAvgWorkTime = running.totalAvgWorkTime + nextUpdate.avgWorkTime/updateCount;
}
qrxStats[statsUpdate.workerId] = statsUpdate;
qrxStats['summary'] = {totalPendingWorkCount: 0,
totalCompletedWorkCount: 0,
totalErrorCount: 0,
totalErrorRate: 0,
totalAvgWorkTime: 0,
totalCompletedWorkBytes: 0} || qrxStats['summary'];
updateSummary(qrxStats['summary'], statsUpdate);
});
// summarize all values for cluster
return Rx.Observable.Create(function(obs){
var statsHeartbeat = Rx.Observable.Interval(period).Subscribe(function(beat) {
obs.OnNext(qrxStats);
return function() {statsSubs.Dispose(); statsHeartbeat.Dispose();}
});
});
}
/**
* Creates an observable sequence of jQuery elements generated by selector on
* body
* @param {String} body
* @param {String} selector
* @param {String} [ext] loaded jQuery extensions
* @param {String} sourceUrl
*/
function createObservablejQuery(body, selector, ext, sourceUrl) {
var srcs = [jquery];
if (ext) {
srcs.push(ext);
}
return Rx.Observable.Create(function(obs){
try {
//console.log('parsing body for selector:' + selector);
jsdom.env({
html: body,
src: srcs,
done:function (err, window) {
var $ = window.jQuery;
// ToDo: Handle empty case
var es = $(selector);
if (es && es.length == 0) {
obs.OnCompleted();
} else {
// emit each selected element
$.each(es, function(k, v){
obs.OnNext({elem:$(this), sourceUrl:sourceUrl});
if (k == (es.length - 1)) {
obs.OnCompleted();
}
});
}
}});// end jsdom
} catch (e){
//console.log('error!');
obs.OnCompleted();
}
return function(){};
});
}
function loadData(file, d3Loader) {
return Rx.Observable.create(observer => {
d3Loader(file, (error, data) => {
if (error) {
observer.onError(error);
}
observer.onNext(data);
observer.onCompleted();
});
});
}
const checkBox = document.querySelector("input")
const checked = Rx.Observable
.fromEvent(checkBox,'change')
.map(evt=>evt.target.checked);
const timedChecked = Rx.Observable.of(true)
.delay(2000)
// clear timeout if checked event happens
.takeUntil(checked);
const trueOrFalse = Rx.Observable
.merge(checked, timedChecked)
.startWith(false)
const createState = loadData('data.tsv', d3.tsv)
.map( eachRow =>
trueOrFalse.map( evt =>
({
function() {
workInFlight--;
Rx.Observable.Start(getNextWork);}
Qrx.prototype.workObservable = function() {
// immediately 'complete' any workers who subscribe
// to a stopped queue
if (this.queueStopped) {
return Rx.Observable.Empty();
}
var self = this;
var rc = newRedisClient(this.redisOptions);
rc.incr(this.workerCount);
// each work subscription keeps track of how much work
// is in flight
var workInFlight = 0;
return Rx.Observable.Create(function(obs) {
function getNextWork(){
// this will set n callbacks where n == throttle
while (workInFlight < self.workThrottle){
workInFlight++;
self.pending.blockingDequeue(rc, 0, function(err, workItem) {
if (workItem.work != this.STOP_MESSAGE) {
// add it to the working set
self.workingSet.addToSet(workItem, function(err, result) {
if (!err){
// dispatch to the worker
// workers get only the information they need
workItem.startTime = Date.now();
var workObj = {work: workItem.work,
callback:callbackWithTimeout(completeCallbackFn(self,
workItem,
function() {
workInFlight--;
Rx.Observable.Start(getNextWork);}
), self.workTimeout)};
// catch any work exception
try {
obs.OnNext(workObj);
} catch (exn){
// set the exception and mark the work complete
workObj.callback(exn, null);
// Rx next tick self schedule
Rx.Observable.Start(getNextWork);
}
} else {
// fail the worker
obs.OnError(err);
}
});
} else {
// signal worker complete
obs.OnCompleted();
}
});
}
}
// initial kick-off
Rx.Observable.Start(getNextWork);
return function(){rc.quit();};
});
}
var Rx = require('rx').Rx;
var f = function(x) {
console.log(">>>>", x)
for(var i=0; i < 5000000000; i++) {
}
console.log("<<<<", x);
}
var u = Rx.Observable.interval(100);
var v = Rx.Observable.interval(400);
// u.buffer(v).subscribe(f);
u.subscribe(f)