4 files changed, 0 insertions, 151 deletions
diff --git a/server/lib/worker/parent-process.ts b/server/lib/worker/parent-process.ts
deleted file mode 100644
index 48b6c682b..000000000
--- a/server/lib/worker/parent-process.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-import { join } from 'path'
-import Piscina from 'piscina'
-import { processImage } from '@server/helpers/image-utils'
-import { JOB_CONCURRENCY, WORKER_THREADS } from '@server/initializers/constants'
-import { httpBroadcast } from './workers/http-broadcast'
-import { downloadImage } from './workers/image-downloader'
-let downloadImageWorker: Piscina
-function downloadImageFromWorker (options: Parameters<typeof downloadImage>[0]): Promise<ReturnType<typeof downloadImage>> {
-  if (!downloadImageWorker) {
-    downloadImageWorker = new Piscina({
-      filename: join(__dirname, 'workers', 'image-downloader.js'),
-      concurrentTasksPerWorker: WORKER_THREADS.DOWNLOAD_IMAGE.CONCURRENCY,
-      maxThreads: WORKER_THREADS.DOWNLOAD_IMAGE.MAX_THREADS
-    })
-  }
-  return downloadImageWorker.run(options)
-}
-// ---------------------------------------------------------------------------
-let processImageWorker: Piscina
-function processImageFromWorker (options: Parameters<typeof processImage>[0]): Promise<ReturnType<typeof processImage>> {
-  if (!processImageWorker) {
-    processImageWorker = new Piscina({
-      filename: join(__dirname, 'workers', 'image-processor.js'),
-      concurrentTasksPerWorker: WORKER_THREADS.PROCESS_IMAGE.CONCURRENCY,
-      maxThreads: WORKER_THREADS.PROCESS_IMAGE.MAX_THREADS
-    })
-  }
-  return processImageWorker.run(options)
-}
-// ---------------------------------------------------------------------------
-let parallelHTTPBroadcastWorker: Piscina
-function parallelHTTPBroadcastFromWorker (options: Parameters<typeof httpBroadcast>[0]): Promise<ReturnType<typeof httpBroadcast>> {
-  if (!parallelHTTPBroadcastWorker) {
-    parallelHTTPBroadcastWorker = new Piscina({
-      filename: join(__dirname, 'workers', 'http-broadcast.js'),
-      // Keep it sync with job concurrency so the worker will accept all the requests sent by the parallelized jobs
-      concurrentTasksPerWorker: JOB_CONCURRENCY['activitypub-http-broadcast-parallel'],
-      maxThreads: 1
-    })
-  }
-  return parallelHTTPBroadcastWorker.run(options)
-}
-// ---------------------------------------------------------------------------
-let sequentialHTTPBroadcastWorker: Piscina
-function sequentialHTTPBroadcastFromWorker (options: Parameters<typeof httpBroadcast>[0]): Promise<ReturnType<typeof httpBroadcast>> {
-  if (!sequentialHTTPBroadcastWorker) {
-    sequentialHTTPBroadcastWorker = new Piscina({
-      filename: join(__dirname, 'workers', 'http-broadcast.js'),
-      // Keep it sync with job concurrency so the worker will accept all the requests sent by the parallelized jobs
-      concurrentTasksPerWorker: JOB_CONCURRENCY['activitypub-http-broadcast'],
-      maxThreads: 1
-    })
-  }
-  return sequentialHTTPBroadcastWorker.run(options)
-}
-export {
-  downloadImageFromWorker,
-  processImageFromWorker,
-  parallelHTTPBroadcastFromWorker,
-  sequentialHTTPBroadcastFromWorker
-}
diff --git a/server/lib/worker/workers/http-broadcast.ts b/server/lib/worker/workers/http-broadcast.ts
deleted file mode 100644
index 8c9c6b8ca..000000000
--- a/server/lib/worker/workers/http-broadcast.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { map } from 'bluebird'
-import { logger } from '@server/helpers/logger'
-import { doRequest, PeerTubeRequestOptions } from '@server/helpers/requests'
-import { BROADCAST_CONCURRENCY } from '@server/initializers/constants'
-async function httpBroadcast (payload: {
-  uris: string[]
-  requestOptions: PeerTubeRequestOptions
-}) {
-  const { uris, requestOptions } = payload
-  const badUrls: string[] = []
-  const goodUrls: string[] = []
-  await map(uris, async uri => {
-    try {
-      await doRequest(uri, requestOptions)
-      goodUrls.push(uri)
-    } catch (err) {
-      logger.debug('HTTP broadcast to %s failed.', uri, { err })
-      badUrls.push(uri)
-    }
-  }, { concurrency: BROADCAST_CONCURRENCY })
-  return { goodUrls, badUrls }
-}
-module.exports = httpBroadcast
-export {
-  httpBroadcast
-}
diff --git a/server/lib/worker/workers/image-downloader.ts b/server/lib/worker/workers/image-downloader.ts
deleted file mode 100644
index 209594589..000000000
--- a/server/lib/worker/workers/image-downloader.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import { remove } from 'fs-extra'
-import { join } from 'path'
-import { processImage } from '@server/helpers/image-utils'
-import { doRequestAndSaveToFile } from '@server/helpers/requests'
-import { CONFIG } from '@server/initializers/config'
-async function downloadImage (options: {
-  url: string
-  destDir: string
-  destName: string
-  size: { width: number, height: number }
-}) {
-  const { url, destDir, destName, size } = options
-  const tmpPath = join(CONFIG.STORAGE.TMP_DIR, 'pending-' + destName)
-  await doRequestAndSaveToFile(url, tmpPath)
-  const destPath = join(destDir, destName)
-  try {
-    await processImage({ path: tmpPath, destination: destPath, newSize: size })
-  } catch (err) {
-    await remove(tmpPath)
-    throw err
-  }
-  return destPath
-}
-module.exports = downloadImage
-export {
-  downloadImage
-}
diff --git a/server/lib/worker/workers/image-processor.ts b/server/lib/worker/workers/image-processor.ts
deleted file mode 100644
index 0ab41a5a0..000000000
--- a/server/lib/worker/workers/image-processor.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import { processImage } from '@server/helpers/image-utils'
-module.exports = processImage
-export {
-  processImage
-}

diff --git a/server/lib/worker/parent-process.ts b/server/lib/worker/parent-process.ts deleted file mode 100644 index 48b6c682b..000000000 --- a/server/lib/worker/parent-process.ts +++ /dev/null
@@ -1,77 +0,0 @@
1	import { join } from 'path'
2	import Piscina from 'piscina'
3	import { processImage } from '@server/helpers/image-utils'
4	import { JOB_CONCURRENCY, WORKER_THREADS } from '@server/initializers/constants'
5	import { httpBroadcast } from './workers/http-broadcast'
6	import { downloadImage } from './workers/image-downloader'
7
8	let downloadImageWorker: Piscina
9
10	function downloadImageFromWorker (options: Parameters<typeof downloadImage>[0]): Promise<ReturnType<typeof downloadImage>> {
11	if (!downloadImageWorker) {
12	downloadImageWorker = new Piscina({
13	filename: join(__dirname, 'workers', 'image-downloader.js'),
14	concurrentTasksPerWorker: WORKER_THREADS.DOWNLOAD_IMAGE.CONCURRENCY,
15	maxThreads: WORKER_THREADS.DOWNLOAD_IMAGE.MAX_THREADS
16	})
17	}
18
19	return downloadImageWorker.run(options)
20	}
21
22	// ---------------------------------------------------------------------------
23
24	let processImageWorker: Piscina
25
26	function processImageFromWorker (options: Parameters<typeof processImage>[0]): Promise<ReturnType<typeof processImage>> {
27	if (!processImageWorker) {
28	processImageWorker = new Piscina({
29	filename: join(__dirname, 'workers', 'image-processor.js'),
30	concurrentTasksPerWorker: WORKER_THREADS.PROCESS_IMAGE.CONCURRENCY,
31	maxThreads: WORKER_THREADS.PROCESS_IMAGE.MAX_THREADS
32	})
33	}
34
35	return processImageWorker.run(options)
36	}
37
38	// ---------------------------------------------------------------------------
39
40	let parallelHTTPBroadcastWorker: Piscina
41
42	function parallelHTTPBroadcastFromWorker (options: Parameters<typeof httpBroadcast>[0]): Promise<ReturnType<typeof httpBroadcast>> {
43	if (!parallelHTTPBroadcastWorker) {
44	parallelHTTPBroadcastWorker = new Piscina({
45	filename: join(__dirname, 'workers', 'http-broadcast.js'),
46	// Keep it sync with job concurrency so the worker will accept all the requests sent by the parallelized jobs
47	concurrentTasksPerWorker: JOB_CONCURRENCY['activitypub-http-broadcast-parallel'],
48	maxThreads: 1
49	})
50	}
51
52	return parallelHTTPBroadcastWorker.run(options)
53	}
54
55	// ---------------------------------------------------------------------------
56
57	let sequentialHTTPBroadcastWorker: Piscina
58
59	function sequentialHTTPBroadcastFromWorker (options: Parameters<typeof httpBroadcast>[0]): Promise<ReturnType<typeof httpBroadcast>> {
60	if (!sequentialHTTPBroadcastWorker) {
61	sequentialHTTPBroadcastWorker = new Piscina({
62	filename: join(__dirname, 'workers', 'http-broadcast.js'),
63	// Keep it sync with job concurrency so the worker will accept all the requests sent by the parallelized jobs
64	concurrentTasksPerWorker: JOB_CONCURRENCY['activitypub-http-broadcast'],
65	maxThreads: 1
66	})
67	}
68
69	return sequentialHTTPBroadcastWorker.run(options)
70	}
71
72	export {
73	downloadImageFromWorker,
74	processImageFromWorker,
75	parallelHTTPBroadcastFromWorker,
76	sequentialHTTPBroadcastFromWorker
77	}


diff --git a/server/lib/worker/workers/http-broadcast.ts b/server/lib/worker/workers/http-broadcast.ts deleted file mode 100644 index 8c9c6b8ca..000000000 --- a/server/lib/worker/workers/http-broadcast.ts +++ /dev/null
@@ -1,32 +0,0 @@
1	import { map } from 'bluebird'
2	import { logger } from '@server/helpers/logger'
3	import { doRequest, PeerTubeRequestOptions } from '@server/helpers/requests'
4	import { BROADCAST_CONCURRENCY } from '@server/initializers/constants'
5
6	async function httpBroadcast (payload: {
7	uris: string[]
8	requestOptions: PeerTubeRequestOptions
9	}) {
10	const { uris, requestOptions } = payload
11
12	const badUrls: string[] = []
13	const goodUrls: string[] = []
14
15	await map(uris, async uri => {
16	try {
17	await doRequest(uri, requestOptions)
18	goodUrls.push(uri)
19	} catch (err) {
20	logger.debug('HTTP broadcast to %s failed.', uri, { err })
21	badUrls.push(uri)
22	}
23	}, { concurrency: BROADCAST_CONCURRENCY })
24
25	return { goodUrls, badUrls }
26	}
27
28	module.exports = httpBroadcast
29
30	export {
31	httpBroadcast
32	}


diff --git a/server/lib/worker/workers/image-downloader.ts b/server/lib/worker/workers/image-downloader.ts deleted file mode 100644 index 209594589..000000000 --- a/server/lib/worker/workers/image-downloader.ts +++ /dev/null
@@ -1,35 +0,0 @@
1	import { remove } from 'fs-extra'
2	import { join } from 'path'
3	import { processImage } from '@server/helpers/image-utils'
4	import { doRequestAndSaveToFile } from '@server/helpers/requests'
5	import { CONFIG } from '@server/initializers/config'
6
7	async function downloadImage (options: {
8	url: string
9	destDir: string
10	destName: string
11	size: { width: number, height: number }
12	}) {
13	const { url, destDir, destName, size } = options
14
15	const tmpPath = join(CONFIG.STORAGE.TMP_DIR, 'pending-' + destName)
16	await doRequestAndSaveToFile(url, tmpPath)
17
18	const destPath = join(destDir, destName)
19
20	try {
21	await processImage({ path: tmpPath, destination: destPath, newSize: size })
22	} catch (err) {
23	await remove(tmpPath)
24
25	throw err
26	}
27
28	return destPath
29	}
30
31	module.exports = downloadImage
32
33	export {
34	downloadImage
35	}


diff --git a/server/lib/worker/workers/image-processor.ts b/server/lib/worker/workers/image-processor.ts deleted file mode 100644 index 0ab41a5a0..000000000 --- a/server/lib/worker/workers/image-processor.ts +++ /dev/null
@@ -1,7 +0,0 @@
1	import { processImage } from '@server/helpers/image-utils'
2
3	module.exports = processImage
4
5	export {
6	processImage
7	}