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
|
# progress-stream
Read the progress of a stream. Supports speed and eta.
Gets the lengths of the stream automatically if you're using the request or http module. You can also pass the length on initiation. Progress-stream will also check to see if the stream already have a length property.
npm install progress-stream
## Usage
This example copies a large file, and prints out the percentage, speed and remaining every 100ms.
```js
var progress = require('progress-stream');
var fs = require('fs');
var stat = fs.statSync(filename);
var str = progress({
length: stat.size,
time: 100
});
str.on('progress', function(progress) {
console.log(progress);
/*
{
percentage: 9.05,
transferred: 949624,
length: 10485760,
remaining: 9536136,
eta: 42,
runtime: 3,
delta: 295396,
speed: 949624
}
*/
});
fs.createReadStream(filename)
.pipe(str)
.pipe(fs.createWriteStream(output));
```
## Methods
### progress([options], [onprogress])
You can instantiate in two ways:
``` js
var str = progress({time:100});
str.on('progress', function(progress) { ... });
```
or inline the progress listener
``` js
var str = progress({time:100}, function(progress) { ... });
```
## Properties
### .progress
You can get the progress from the progress property.
``` js
var str = progress({time:100});
console.log(str.progress);
/*
{
percentage: 9.05,
transferred: 949624,
length: 10485760,
remaining: 9536136,
eta: 10,
runtime: 0,
delta: 295396,
speed: 949624
}
*/
```
## Events
### on('progress', function(progress) { ... })
``` js
var str = progress({time:100});
str.on('progress', function(progress) { ... });
```
## Options
### time(integer)
Sets how often progress events is emitted. If omitted then defaults to emit every time a chunk is received.
### speed(integer)
Sets how long the speedometer needs to calculate the speed. Defaults to 5 sec.
### length(integer)
If you already know the length of the stream, then you can set it. Defaults to 0.
### drain(boolean)
In case you don't want to include a readstream after progress-stream, set to true to drain automatically. Defaults to false.
### transferred(integer)
If you want to set how much data have previous been downloaded. Useful for a resumed download.
## Examples
### Using the request module
This example uses request to download a 100 MB file, and writes out the percentage every second.
You can also find an example in `test/request.js`.
``` js
var progress = require('progress-stream');
var req = require('request');
var fs = require('fs');
var str = progress({
time: 1000
});
str.on('progress', function(progress) {
console.log(Math.round(progress.percentage)+'%');
});
req('http://cachefly.cachefly.net/100mb.test', { headers: { 'user-agent': 'test' }})
.pipe(str)
.pipe(fs.createWriteStream('test.data'));
```
### Using the http module
In `test/http.js` it's shown how to do it with the http module.
## Methods
### `setLength(newLength)`
Sometimes, you don't know how big a stream is right away (e.g. multipart file uploads). You might find out after a few chunks have already passed through the stream, seconds or even minutes later. In this case, you can use the `setLength` method to recalculate the relevant tracked progress data.
```js
var str = progress({});
someFickleStreamInstance.pipe(str).pipe(fs.createWriteStream('test.data'));
someFickleStreamInstance.on('conviction', function nowIKnowMyLength (actualLength) {
str.setLength(actualLength);
});
```
|
