return Rx.Observable.create(observer => {
let disposables = new Rx.CompositeDisposable();
if (_this.limitCheckSubscriber === null) {
_log.debug('client side limit check not up, will delegate to to server');
observer.onNext(true);
observer.onCompleted();
} else {
_log.debug(`checking if limit is ok with ${_this.limitCheckSubscriber}`);
const topic = `limit-check-response (${_this.limitCheckId++})`;
let limitCheckResponse:(msg:any) => void = (msg) => {
_log.debug(`${_this.limitCheckSubscriber} limit check response was ${msg}`);
observer.onNext(msg.result);
observer.onCompleted();
};
fin.desktop.InterApplicationBus.subscribe(_this.limitCheckSubscriber, topic, limitCheckResponse);
fin.desktop.InterApplicationBus.send(_this.limitCheckSubscriber, REQUEST_LIMIT_CHECK_TOPIC, {
id: _this.limitCheckId,
responseTopic: topic,
tradedCurrencyPair: tradedCurrencyPair,
notional: notional,
rate: executablePrice
});
disposables.add(Rx.Disposable.create(() => {
fin.desktop.InterApplicationBus.unsubscribe(_this.limitCheckSubscriber, topic, limitCheckResponse);
}));
}
return disposables;
});
static _replicateAll(input, proxy) {
if (!input || !proxy) { return; }
let subscriptions = new Rx.CompositeDisposable();
for (let key in proxy.proxiedProps) { if (proxy.proxiedProps.hasOwnProperty(key)) {
let proxiedProperty = proxy.proxiedProps[key];
let subscription;
if (typeof input.event$ === 'function' && proxiedProperty._hasEvent$) {
subscription = DataFlowNode._replicateAllEvent$(input, key, proxiedProperty);
} else if (!input.hasOwnProperty(key) && input instanceof InputProxy) {
subscription = DataFlowNode._replicate(input.get(key), proxiedProperty);
} else if (typeof input.get === 'function' && input.get(key) !== null) {
subscription = DataFlowNode._replicate(input.get(key), proxiedProperty);
} else if (typeof input === 'object' && input.hasOwnProperty(key)) {
if (!input[key]) {
input[key] = new Rx.Subject();
}
subscription = DataFlowNode._replicate(input[key], proxiedProperty);
} else {
throw new CycleInterfaceError('Input should have the required property ' +
key, String(key)
);
}
subscriptions.add(subscription);
}}
return subscriptions;
}
const start = () => {
const allDisposable = new Rx.CompositeDisposable();
allDisposable.add(allRoutesObservable.connect());
subRouters.forEach(router => {
allDisposable.add(router.start());
})
return allDisposable;
};
static _replicateAllEvent$(input, selector, proxyObj) {
let subscriptions = new Rx.CompositeDisposable();
for (let eventName in proxyObj) { if (proxyObj.hasOwnProperty(eventName)) {
if (eventName !== '_hasEvent$') {
let event$ = input.event$(selector, eventName);
if (event$ !== null) {
let subscription = DataFlowNode._replicate(event$, proxyObj[eventName]);
subscriptions.add(subscription);
}
}
}}
return subscriptions;
}
const connect = () => {
const allDisposable = new Rx.CompositeDisposable();
const children = getChildrenSubject && getChildrenSubject.getValue();
if (children) {
const keys = Object.keys(children);
keys.forEach(key => allDisposable.add(
children[key].getValue().connect()
));
}
allDisposable.add(
asObservable().connect()
);
return allDisposable;
};
// Private: Listens for messages directed at this bot that contain the word
// 'deal,' and poll players in response.
//
// Returns a {Disposable} that will end this subscription
respondToMessages() {
let messages = rx.Observable.fromEvent(this.slack, Slack.RTM_EVENTS.MESSAGE);
rx.Observable.fromEvent(this.slack, Slack.RTM_EVENTS.CHANNEL_JOINED).subscribe(e => {
this.slack.sendMessage(e.channel, this.welcomeMessage());
});
let atMentions = messages.where(e => e.text && e.text.toLowerCase().match(this.selfname));
let disp = new rx.CompositeDisposable();
disp.add(this.handleStartGameMessages(messages));
return disp;
}
// Private: Listens for messages directed at this bot that contain the word
// 'deal,' and poll players in response.
//
// Returns a {Disposable} that will end this subscription
respondToMessages() {
let messages = rx.Observable.fromEvent(this.slack, 'message')
.where(e => e.type === 'message');
let atMentions = messages.where(e =>
MessageHelpers.containsUserMention(e.text, this.slack.self.id));
let disp = new rx.CompositeDisposable();
disp.add(this.handleDealGameMessages(messages, atMentions));
disp.add(this.handleConfigMessages(atMentions));
return disp;
}
componentWillReceiveProps(nextProps, nextContext) {
if (
!isActionable ||
!hasRefetcher ||
!options.shouldRefetch(
this.props,
nextProps,
getChildContext(Component.contextTypes, this.context),
getChildContext(Component.contextTypes, nextContext)
)
) {
return;
}
const actionArgs = getActionArgs(
this.props,
getChildContext(Component.contextTypes, this.context)
);
const fetch$ = action.apply(null, actionArgs);
if (__DEV__ && !Observable.isObservable(fetch$)) {
throw new Error(
'fetch action should return observable'
);
}
const subscription = fetch$.subscribe(
() => {},
options.errorHandler
);
this.__subscriptions.add(subscription);
}
componentDidMount() {
if (isPrimed(this.props, this.context)) {
log('container is primed');
return null;
}
if (!isActionable) {
log(`${Component.displayName} container is not actionable`);
return null;
}
const actionArgs = getActionArgs(this.props, this.context);
const fetch$ = action.apply(null, actionArgs);
if (__DEV__ && !Observable.isObservable(fetch$)) {
console.log(fetch$);
throw new Error(
`Action creator should return an Observable but got ${fetch$}.
Check the action creator for fetch action ${options.fetchAction}`
);
}
const subscription = fetch$.subscribe(
() => {},
options.handleError
);
return this.__subscriptions.add(subscription);
}
return function dispose() {
subscription.dispose();
for (var x in subjects) {
if (subjects.hasOwnProperty(x)) {
subjects[x].dispose();
}
}
};
setTimeout(function () {
for (var _name4 in observables) {
if (observables.hasOwnProperty(_name4) && subjects.hasOwnProperty(_name4) && !subjects[_name4].isDisposed) {
subscription.add(observables[_name4].doOnError(logToConsoleError).subscribe(subjects[_name4].asObserver()));
}
}
observer.onNext(subscription);
}, 1);
function dispose () {
if (!disposed) {
disposed = true;
subs.dispose();
done();
proc.kill();
}
}
function subscribeDispatchers(element, eventStreams) {
if (!eventStreams || typeof eventStreams !== 'object') { return; }
var disposables = new Rx.CompositeDisposable();
for (let streamName in eventStreams) { if (eventStreams.hasOwnProperty(streamName)) {
if (streamName.endsWith('$') &&
typeof eventStreams[streamName].subscribe === 'function')
{
let eventName = streamName.slice(0, -1);
let disposable = eventStreams[streamName].subscribe(
makeDispatchFunction(element, eventName)
);
disposables.add(disposable);
}
}}
return disposables;
}
var obs = Observable.create(function (observer) {
var disposed = false;
var subs = new Rx.CompositeDisposable();
opts = defaults(opts || {}, {
cwd: process.cwd(),
env: process.env,
encoding: 'utf8'
});
var params =
defaults(
pick(opts, shellOpts),
pick(sh, shellOpts)
);
var proc =
obs._process =
spawn(params.shell, params.shellArgs.concat(command), opts);
function done () {
proc.removeAllListeners();
}
function completed (error) {
if (!disposed) {
observer[error ? 'onError' : 'onCompleted'](error);
done();
}
}
function dispose () {
if (!disposed) {
disposed = true;
subs.dispose();
done();
proc.kill();
}
}
proc.on('error', completed);
proc.on('close', completed);
if (!opts.stdio) {
var onNext = observer.onNext.bind(observer);
['stdin', 'stdout', 'stderr'].
forEach(function (fd) {
if (proc[fd]) {
proc[fd].setEncoding(opts.encoding);
subs.add(fromStream(proc[fd]).subscribe(onNext));
}
});
}
return Rx.Disposable.create(dispose);
});
const build = (args) => {
const stream = ValueStream(args.reduce(chain, ref))
.tap(function (x) {
options && options.debug && console.log(`firebase query ${args.join('/')}`, x)
})
.replay(null, 1)
const disposable = stream.connect()
compositeDisposable.add(disposable)
return stream
}
return Rx.Observable.create((o:Rx.Observer<TResponse>) => {
_log.debug(`Doing a RPC to [${remoteProcedure}]. Is connected [${_this._isConnected}]`);
let disposables = new Rx.CompositeDisposable();
if (!_this.isConnected) {
o.onError(new Error(`Session not connected, can\'t perform remoteProcedure ${remoteProcedure}`));
return disposables;
}
let isDisposed:boolean;
let dto = [{
replyTo: responseTopic,
Username: _this._userName,
payload: payload
}];
_this._autobahn.session.call(remoteProcedure, dto).then(
result => {
if (!isDisposed) {
o.onNext(result);
o.onCompleted();
} else {
_log.verbose(`Ignoring response for remoteProcedure [${remoteProcedure}] as stream disposed`);
}
},
error => {
if (!isDisposed) {
o.onError(error);
} else {
_log.error(`Ignoring error for remoteProcedure [${remoteProcedure}] as stream disposed.`, error);
}
}
);
disposables.add(Rx.Disposable.create(() => {
isDisposed = true;
}));
return disposables;
});
const connect = () => {
const children = getChildrenSubject && getChildrenSubject.getValue();
if (children) {
const keys = Object.keys(children);
keys.forEach(key => connectDisposable.add(
children[key].getValue().connect()
));
}
connectDisposable.add(
asObservable().connect()
);
return connectDisposable;
};
return Rx.Observable.create((o: Rx.Observer<TResponse>) => {
let disposables = new Rx.CompositeDisposable();
_log.debug(`Subscribing to topic [${topic}]. Is connected [${_this._isConnected}]`);
if (!_this.isConnected) {
o.onError(new Error(`Session not connected, can\'t subscribe to topic [${topic}]`));
return disposables;
}
let subscription;
_this._autobahn.session.subscribe(topic, (response:Array<TResponse>) => {
this._logResponse(topic, response);
o.onNext(response[0]);
}).then((sub:autobahn.Subscription) => {
// subscription succeeded, subscription is an instance of autobahn.Subscription
_log.verbose(`subscription acked on topic [${topic}]`);
subscription = sub;
}, (error: autobahn.Error) => {
// subscription failed, error is an instance of autobahn.Error
_log.error(`Error on topic ${topic}`, error);
o.onError(error);
});
disposables.add(Rx.Disposable.create(() => {
if (!subscription) {
return;
}
try {
_this._autobahn.session.unsubscribe(subscription).then(
gone => { _log.verbose(`Successfully unsubscribing from topic ${topic}`); },
err => { _log.error(`Error unsubscribing from topic ${topic}`, err); }
);
} catch (err) {
_log.error(`Error thrown unsubscribing from topic ${topic}`, err);
}
}));
return disposables;
});
return Rx.Observable.create(function (observer) {
var subscription = new Rx.CompositeDisposable();
setTimeout(function () {
for (var _name4 in observables) {
if (observables.hasOwnProperty(_name4) && subjects.hasOwnProperty(_name4) && !subjects[_name4].isDisposed) {
subscription.add(observables[_name4].doOnError(logToConsoleError).subscribe(subjects[_name4].asObserver()));
}
}
observer.onNext(subscription);
}, 1);
return function dispose() {
subscription.dispose();
for (var x in subjects) {
if (subjects.hasOwnProperty(x)) {
subjects[x].dispose();
}
}
};
});
inject() {
if (this._wasInjected) {
console.warn('DataFlowNode has already been injected an input.');
}
if (this._definitionFn.length !== arguments.length) {
console.warn('The call to inject() should provide the inputs that this ' +
'DataFlowNode expects according to its definition function.');
}
for (let i = 0; i < this._definitionFn.length; i++) {
let subscription = DataFlowNode._replicateAll(arguments[i], this._proxies[i]);
this._subscription.add(subscription);
}
this._wasInjected = true;
if (arguments.length === 1) {
return arguments[0];
} else if (arguments.length > 1) {
return Array.prototype.slice.call(arguments);
} else {
return null;
}
}
export const makeFirebaseDriver = (ref, options) => {
const cache = {}
const compositeDisposable = new CompositeDisposable()
// there are other chainable firebase query buiders, this is wot we need now
const query = (parentRef, { orderByChild, equalTo }) => {
let childRef = parentRef
if (orderByChild) { childRef = childRef.orderByChild(orderByChild) }
if (equalTo) { childRef = childRef.equalTo(equalTo) }
return childRef
}
// used to build fb ref, each value passed is either child or k:v query def
const chain = (a, v) => typeof v === 'object' && query(a, v) || a.child(v)
// building query from fb api is simply mapping the args to chained fn calls
const build = (args) => {
const stream = ValueStream(args.reduce(chain, ref))
.tap(function (x) {
options && options.debug && console.log(`firebase query ${args.join('/')}`, x)
})
.replay(null, 1)
const disposable = stream.connect()
compositeDisposable.add(disposable)
return stream
}
// SIDE EFFECT: build and add to cache if not in cache
const cacheOrBuild = (key, args) => cache[key] || (cache[key] = build(args))
return function firebaseDriver() {
let fn = (...args) => cacheOrBuild(JSON.stringify(args), args)
fn.dispose = () => compositeDisposable.dispose()
return fn
}
}
dispose() {
if (this._subscription && typeof this._subscription.dispose === 'function') {
this._subscription.dispose();
}
}
fn.dispose = () => compositeDisposable.dispose()
export const createInitialNode = ({
addChildrenSubject,
getChildrenSubject,
pauser,
observable,
hookMap,
setNextState,
setCompleted,
provisional
}) => {
const observableSubject = new Rx.ReplaySubject(1);
// Great name right?
const combinedObservable = observableSubject
.flatMapLatest(obs => obs);
const externalObservable = combinedObservable
.replay();
const child = createChildAccessor(addChildrenSubject, getChildrenSubject);
const nodeSubject = new Rx.BehaviorSubject();
const asObservable = () => externalObservable;
const reduce = createReduce(
combinedObservable,
nodeSubject.asObservable(),
hookMap,
pauser
);
const connectDisposable = new Rx.CompositeDisposable();
const connect = () => {
const children = getChildrenSubject && getChildrenSubject.getValue();
if (children) {
const keys = Object.keys(children);
keys.forEach(key => connectDisposable.add(
children[key].getValue().connect()
));
}
connectDisposable.add(
asObservable().connect()
);
return connectDisposable;
};
const setInitialState = (initialState) => {
const currentNode = nodeSubject.getValue()
if (!currentNode.provisional) {
throwFinalizedError();
} else {
createTree({
initialState,
createNode,
pauser,
hookMap,
provisional: false,
provisionalNode: node
});
return publishNode(nodeSubject.getValue());
}
};
const setNodeCompleted = () => {
setCompleted();
observableSubject.onCompleted();
// Dispose on next tick so onComplete handlers
// will be invoked.
setTimeout(() => connectDisposable.dispose());
};
if (observable) {
observableSubject.onNext(observable);
}
const nodeProps = {
addChildrenSubject,
getChildrenSubject,
reduce,
child,
setNextState,
setCompleted: setNodeCompleted,
nodeSubject,
provisional: !!provisional,
provisionalNode: !!provisional && node,
pauser,
combinedObservable,
observableSubject,
asObservable,
connect,
setInitialState
};
const accessor = createNodeAccessor(nodeProps);
const compose = nodeProps.compose = wrapInPublish((nodeMap) => createComposedNode({
nodeMap,
accessor,
pauser,
hookMap
}));
const node = Object.assign(
wrapInPublish(accessor),
nodeProps
);
nodeSubject.onNext(node);
return node;
};
setTimeout(() => connectDisposable.dispose());
keys.forEach(key => connectDisposable.add( children[key].getValue().connect() ));
Object.keys(this.observableMap).forEach((key) => {
const disposable = this.observableMap[key].subscribe((val) => this.setState({ [key]: val }));
this.disposableBag.add(disposable);
});
subRouters.forEach(router => {
allDisposable.add(router.start());
})
dispose() {
this._disposables.dispose();
}
addDisposable(disposable) {
this._disposables.add(disposable);
}