-
Notifications
You must be signed in to change notification settings - Fork 39
/
share.js
212 lines (193 loc) · 7.52 KB
/
share.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
/* jshint node: true, esnext: true */
'use strict';
var bodyParser = require('body-parser');
var requestp = require('request-promise');
var rperrors = require('request-promise/errors');
var gistAPI = 'https://api.github.com/gists';
var prefixSeparator = '-'; // change the regex below if you change this
var splitPrefixRe = /^(([^-]+)-)?(.*)$/;
//You can test like this with httpie:
//echo '{ "test": "me" }' | http post localhost:3001/api/v1/share
function makeGist(serviceOptions, body) {
var gistFile = {};
gistFile[serviceOptions.gistFilename || 'usercatalog.json'] = { content: body };
var headers = {
'User-Agent': serviceOptions.userAgent || 'TerriaJS-Server',
'Accept': 'application/vnd.github.v3+json'
};
if (serviceOptions.accessToken !== undefined) {
headers['Authorization'] = 'token ' + serviceOptions.accessToken;
}
return requestp({
url: gistAPI,
method: 'POST',
headers: headers,
json: true,
body: {
files: gistFile,
description: (serviceOptions.gistDescription || 'User-created catalog'),
public: false
}, transform: function(body, response) {
if (response.statusCode === 201) {
console.log('Created ID ' + response.body.id + ' using Gist service');
return response.body.id;
} else {
return response;
}
}
});
}
// Test: http localhost:3001/api/v1/share/g-98e01625db07a78d23b42c3dbe08fe20
function resolveGist(serviceOptions, id) {
var headers = {
'User-Agent': serviceOptions.userAgent || 'TerriaJS-Server',
'Accept': 'application/vnd.github.v3+json'
};
if (serviceOptions.accessToken !== undefined) {
headers['Authorization'] = 'token ' + serviceOptions.accessToken;
}
return requestp({
url: gistAPI + '/' + id,
headers: headers,
json: true,
transform: function(body, response) {
if (response.statusCode >= 300) {
return response;
} else {
return body.files[Object.keys(body.files)[0]].content; // find the contents of the first file in the gist
}
}
});
}
/*
Generate short ID by hashing body, converting to base62 then truncating.
*/
function shortId(body, length) {
var hmac = require('crypto').createHmac('sha1', body).digest();
var base62 = require("base-x")('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ');
var fullkey = base62.encode(hmac);
return fullkey.slice(0, length); // if length undefined, return the whole thing
}
var _S3;
function S3(serviceOptions) {
if (_S3) {
return _S3;
} else {
var aws = require('aws-sdk');
aws.config.update({
region: serviceOptions.region
});
// if no credentials provided, we assume that they're being provided as environment variables or in a file
if (serviceOptions.accessKeyId) {
aws.config.update({
accessKeyId: serviceOptions.accessKeyId,
secretAccessKey: serviceOptions.secretAccessKey
});
}
_S3 = new aws.S3();
return _S3;
}
}
// We append some pseudo-dir prefixes into the actual object ID to avoid thousands of objects in a single pseudo-directory.
// MyRaNdoMkey => M/y/MyRaNdoMkey
const idToObject = (id) => id.replace(/^(.)(.)/, '$1/$2/$1$2');
function saveS3(serviceOptions, body) {
var id = shortId(body, serviceOptions.keyLength);
const params = {
Bucket: serviceOptions.bucket,
Key: idToObject(id),
Body: body
};
return S3(serviceOptions).putObject(params).promise()
.then(function(result) {
console.log('Saved key ' + id + ' to S3 bucket ' + params.Bucket + ':' + params.Key + '. Etag: ' + result.ETag);
return id;
}).catch(function(e) {
console.error(e);
return e;
});
}
function resolveS3(serviceOptions, id) {
const params = {
Bucket: serviceOptions.bucket,
Key: idToObject(id)
};
return S3(serviceOptions).getObject(params).promise()
.then(function(data) {
return data.Body;
}).catch(function(e) {
throw {
response: e,
error: e.message
};
});
}
module.exports = function(hostName, port, options) {
if (!options.shareUrlPrefixes) {
return;
}
var router = require('express').Router();
router.use(bodyParser.text({
type: '*/*',
limit: options.shareMaxRequestSize || '200kb'
}));
// Requested creation of a new short URL.
router.post('/', function(req, res, next) {
if (options.newShareUrlPrefix === undefined || !options.shareUrlPrefixes[options.newShareUrlPrefix]) {
return res.status(404).json({ message: "This server has not been configured to generate new share URLs." });
}
var serviceOptions = options.shareUrlPrefixes[options.newShareUrlPrefix];
var minter = {
'gist': makeGist,
's3': saveS3
}[serviceOptions.service.toLowerCase()];
minter(serviceOptions, req.body).then(function(id) {
id = options.newShareUrlPrefix + prefixSeparator + id;
var resPath = req.baseUrl + '/' + id;
// these properties won't behave correctly unless "trustProxy: true" is set in user's options file.
// they may not behave correctly (especially port) when behind multiple levels of proxy
var resUrl =
req.protocol + '://' +
req.hostname +
(req.header('X-Forwarded-Port') || port) +
resPath;
res .location(resUrl)
.status(201)
.json({ id: id, path: resPath, url: resUrl });
}).catch(rperrors.TransformError, function (reason) {
console.error(JSON.stringify(reason, null, 2));
res.status(500).json({ message: reason.cause.message });
}).catch(function(reason) {
console.warn(JSON.stringify(reason, null, 2));
res.status(500) // probably safest if we always return a consistent error code
.json({ message: reason.error });
});
});
// Resolve an existing ID. We break off the prefix and use it to work out which resolver to use.
router.get('/:id', function(req, res, next) {
var prefix = req.params.id.match(splitPrefixRe)[2] || '';
var id = req.params.id.match(splitPrefixRe)[3];
var resolver;
var serviceOptions = options.shareUrlPrefixes[prefix];
if (!serviceOptions) {
console.error('Share: Unknown prefix to resolve "' + prefix + '", id "' + id + '"');
return res.status(400).send('Unknown share prefix "' + prefix + '"');
} else {
resolver = {
'gist': resolveGist,
's3': resolveS3
}[serviceOptions.service.toLowerCase()];
}
resolver(serviceOptions, id).then(function(content) {
res.send(content);
}).catch(rperrors.TransformError, function (reason) {
console.error(JSON.stringify(reason, null, 2));
res.status(500).send(reason.cause.message);
}).catch(function(reason) {
console.warn(JSON.stringify(reason.response, null, 2));
res.status(404) // probably safest if we always return 404 rather than whatever the upstream provider sets.
.send(reason.error);
});
});
return router;
};