sim1222/nca10.net
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

#2020

Browse Source
This commit is contained in:
syuilo
2018-07-30 07:20:27 +09:00
parent 4e6dcd16ac
commit 83d9730d93
33 changed files with 189 additions and 242 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/server/api/stream/drive.ts
View File

@ -1,10 +1,9 @@
import * as websocket from 'websocket';
import * as redis from 'redis';
import Xev from 'xev';
export default function(request: websocket.request, connection: websocket.connection, subscriber: redis.RedisClient, user: any): void {
export default function(request: websocket.request, connection: websocket.connection, subscriber: Xev, user: any): void {
// Subscribe drive stream
subscriber.subscribe(`misskey:drive-stream:${user._id}`);
subscriber.on('message', (_, data) => {
connection.send(data);
subscriber.on(`drive-stream:${user._id}`, data => {
connection.send(JSON.stringify(data));
});
}

11
src/server/api/stream/games/reversi-game.ts
View File

@ -1,5 +1,5 @@
import * as websocket from 'websocket';
import * as redis from 'redis';
import Xev from 'xev';
import * as CRC32 from 'crc-32';
import ReversiGame, { pack } from '../../../../models/games/reversi/game';
import { publishReversiGameStream } from '../../../../stream';
@ -7,14 +7,13 @@ import Reversi from '../../../../games/reversi/core';
import * as maps from '../../../../games/reversi/maps';
import { ParsedUrlQuery } from 'querystring';
export default function(request: websocket.request, connection: websocket.connection, subscriber: redis.RedisClient, user?: any): void {
export default function(request: websocket.request, connection: websocket.connection, subscriber: Xev, user?: any): void {
const q = request.resourceURL.query as ParsedUrlQuery;
const gameId = q.game;
const gameId = q.game as string;
// Subscribe game stream
subscriber.subscribe(`misskey:reversi-game-stream:${gameId}`);
subscriber.on('message', (_, data) => {
connection.send(data);
subscriber.on(`reversi-game-stream:${gameId}`, data => {
connection.send(JSON.stringify(data));
});
connection.on('message', async (data) => {

11
src/server/api/stream/games/reversi.ts
View File

@ -1,14 +1,13 @@
import * as mongo from 'mongodb';
import * as websocket from 'websocket';
import * as redis from 'redis';
import Xev from 'xev';
import Matching, { pack } from '../../../../models/games/reversi/matching';
import publishUserStream from '../../../../stream';
import { publishUserStream } from '../../../../stream';
export default function(request: websocket.request, connection: websocket.connection, subscriber: redis.RedisClient, user: any): void {
export default function(request: websocket.request, connection: websocket.connection, subscriber: Xev, user: any): void {
// Subscribe reversi stream
subscriber.subscribe(`misskey:reversi-stream:${user._id}`);
subscriber.on('message', (_, data) => {
connection.send(data);
subscriber.on(`reversi-stream:${user._id}`, data => {
connection.send(JSON.stringify(data));
});
connection.on('message', async (data) => {

12
src/server/api/stream/global-timeline.ts
View File

@ -1,5 +1,5 @@
import * as websocket from 'websocket';
import * as redis from 'redis';
import Xev from 'xev';
import { IUser } from '../../../models/user';
import Mute from '../../../models/mute';
@ -7,18 +7,14 @@ import Mute from '../../../models/mute';
export default async function(
request: websocket.request,
connection: websocket.connection,
subscriber: redis.RedisClient,
subscriber: Xev,
user: IUser
) {
// Subscribe stream
subscriber.subscribe(`misskey:global-timeline`);
const mute = await Mute.find({ muterId: user._id });
const mutedUserIds = mute.map(m => m.muteeId.toString());
subscriber.on('message', async (_, data) => {
const note = JSON.parse(data);
// Subscribe stream
subscriber.on('global-timeline', async note => {
//#region 流れてきたNoteがミュートしているユーザーが関わるものだったら無視する
if (mutedUserIds.indexOf(note.userId) != -1) {
return;

105
src/server/api/stream/home.ts
View File

@ -1,5 +1,5 @@
import * as websocket from 'websocket';
import * as redis from 'redis';
import Xev from 'xev';
import * as debug from 'debug';
import User, { IUser } from '../../../models/user';
@ -14,68 +14,54 @@ const log = debug('misskey');
export default async function(
request: websocket.request,
connection: websocket.connection,
subscriber: redis.RedisClient,
subscriber: Xev,
user: IUser,
app: IApp
) {
// Subscribe Home stream channel
subscriber.subscribe(`misskey:user-stream:${user._id}`);
const mute = await Mute.find({ muterId: user._id });
const mutedUserIds = mute.map(m => m.muteeId.toString());
subscriber.on('message', async (channel, data) => {
switch (channel.split(':')[1]) {
case 'user-stream':
try {
const x = JSON.parse(data);
async function onNoteStream(noteId: any) {
const note = await packNote(noteId, user, {
detail: true
});
//#region 流れてきたメッセージがミュートしているユーザーが関わるものだったら無視する
if (x.type == 'note') {
if (mutedUserIds.includes(x.body.userId)) {
return;
}
if (x.body.reply != null && mutedUserIds.includes(x.body.reply.userId)) {
return;
}
if (x.body.renote != null && mutedUserIds.includes(x.body.renote.userId)) {
return;
}
} else if (x.type == 'notification') {
if (mutedUserIds.includes(x.body.userId)) {
return;
}
}
//#endregion
connection.send(JSON.stringify({
type: 'note-updated',
body: {
note: note
}
}));
}
// Renoteなら再pack
if (x.type == 'note' && x.body.renoteId != null) {
x.body.renote = await pack(x.body.renoteId, user, {
detail: true
});
data = JSON.stringify(x);
}
connection.send(data);
} catch (e) {
connection.send(data);
}
break;
case 'note-stream':
const noteId = channel.split(':')[2];
log(`RECEIVED: ${noteId} ${data} by @${user.username}`);
const note = await packNote(noteId, user, {
detail: true
});
connection.send(JSON.stringify({
type: 'note-updated',
body: {
note: note
}
}));
break;
// Subscribe Home stream channel
subscriber.on(`user-stream:${user._id}`, async x => {
//#region 流れてきたメッセージがミュートしているユーザーが関わるものだったら無視する
if (x.type == 'note') {
if (mutedUserIds.includes(x.body.userId)) {
return;
}
if (x.body.reply != null && mutedUserIds.includes(x.body.reply.userId)) {
return;
}
if (x.body.renote != null && mutedUserIds.includes(x.body.renote.userId)) {
return;
}
} else if (x.type == 'notification') {
if (mutedUserIds.includes(x.body.userId)) {
return;
}
}
//#endregion
// Renoteなら再pack
if (x.type == 'note' && x.body.renoteId != null) {
x.body.renote = await pack(x.body.renoteId, user, {
detail: true
});
}
connection.send(JSON.stringify(x));
});
connection.on('message', async data => {
@ -113,9 +99,14 @@ export default async function(
case 'capture':
if (!msg.id) return;
const noteId = msg.id;
log(`CAPTURE: ${noteId} by @${user.username}`);
subscriber.subscribe(`misskey:note-stream:${noteId}`);
log(`CAPTURE: ${msg.id} by @${user.username}`);
subscriber.on(`note-stream:${msg.id}`, onNoteStream);
break;
case 'decapture':
if (!msg.id) return;
log(`DECAPTURE: ${msg.id} by @${user.username}`);
subscriber.off(`note-stream:${msg.id}`, onNoteStream);
break;
}
});

13
src/server/api/stream/hybrid-timeline.ts
View File

@ -1,5 +1,5 @@
import * as websocket from 'websocket';
import * as redis from 'redis';
import Xev from 'xev';
import { IUser } from '../../../models/user';
import Mute from '../../../models/mute';
@ -8,18 +8,17 @@ import { pack } from '../../../models/note';
export default async function(
request: websocket.request,
connection: websocket.connection,
subscriber: redis.RedisClient,
subscriber: Xev,
user: IUser
) {
// Subscribe stream
subscriber.subscribe('misskey:hybrid-timeline', `misskey:hybrid-timeline:${user._id}`);
subscriber.on('hybrid-timeline', onEvent);
subscriber.on(`hybrid-timeline:${user._id}`, onEvent);
const mute = await Mute.find({ muterId: user._id });
const mutedUserIds = mute.map(m => m.muteeId.toString());
subscriber.on('message', async (_, data) => {
const note = JSON.parse(data);
async function onEvent(note: any) {
//#region 流れてきたNoteがミュートしているユーザーが関わるものだったら無視する
if (mutedUserIds.indexOf(note.userId) != -1) {
return;
@ -43,5 +42,5 @@ export default async function(
type: 'note',
body: note
}));
});
}
}

12
src/server/api/stream/local-timeline.ts
View File

@ -1,5 +1,5 @@
import * as websocket from 'websocket';
import * as redis from 'redis';
import Xev from 'xev';
import { IUser } from '../../../models/user';
import Mute from '../../../models/mute';
@ -8,18 +8,14 @@ import { pack } from '../../../models/note';
export default async function(
request: websocket.request,
connection: websocket.connection,
subscriber: redis.RedisClient,
subscriber: Xev,
user: IUser
) {
// Subscribe stream
subscriber.subscribe('misskey:local-timeline');
const mute = await Mute.find({ muterId: user._id });
const mutedUserIds = mute.map(m => m.muteeId.toString());
subscriber.on('message', async (_, data) => {
const note = JSON.parse(data);
// Subscribe stream
subscriber.on('local-timeline', async note => {
//#region 流れてきたNoteがミュートしているユーザーが関わるものだったら無視する
if (mutedUserIds.indexOf(note.userId) != -1) {
return;

9
src/server/api/stream/messaging-index.ts
View File

@ -1,10 +1,9 @@
import * as websocket from 'websocket';
import * as redis from 'redis';
import Xev from 'xev';
export default function(request: websocket.request, connection: websocket.connection, subscriber: redis.RedisClient, user: any): void {
export default function(request: websocket.request, connection: websocket.connection, subscriber: Xev, user: any): void {
// Subscribe messaging index stream
subscriber.subscribe(`misskey:messaging-index-stream:${user._id}`);
subscriber.on('message', (_, data) => {
connection.send(data);
subscriber.on(`messaging-index-stream:${user._id}`, data => {
connection.send(JSON.stringify(data));
});
}

9
src/server/api/stream/messaging.ts
View File

@ -1,16 +1,15 @@
import * as websocket from 'websocket';
import * as redis from 'redis';
import Xev from 'xev';
import read from '../common/read-messaging-message';
import { ParsedUrlQuery } from 'querystring';
export default function(request: websocket.request, connection: websocket.connection, subscriber: redis.RedisClient, user: any): void {
export default function(request: websocket.request, connection: websocket.connection, subscriber: Xev, user: any): void {
const q = request.resourceURL.query as ParsedUrlQuery;
const otherparty = q.otherparty as string;
// Subscribe messaging stream
subscriber.subscribe(`misskey:messaging-stream:${user._id}-${otherparty}`);
subscriber.on('message', (_, data) => {
connection.send(data);
subscriber.on(`messaging-stream:${user._id}-${otherparty}`, data => {
connection.send(JSON.stringify(data));
});
connection.on('message', async (data) => {

7
src/server/api/stream/user-list.ts
View File

@ -1,14 +1,13 @@
import * as websocket from 'websocket';
import * as redis from 'redis';
import Xev from 'xev';
import { ParsedUrlQuery } from 'querystring';
export default function(request: websocket.request, connection: websocket.connection, subscriber: redis.RedisClient, user: any): void {
export default function(request: websocket.request, connection: websocket.connection, subscriber: Xev, user: any): void {
const q = request.resourceURL.query as ParsedUrlQuery;
const listId = q.listId as string;
// Subscribe stream
subscriber.subscribe(`misskey:user-list-stream:${listId}`);
subscriber.on('message', (_, data) => {
subscriber.on(`user-list-stream:${listId}`, data => {
connection.send(data);
});
}