Wat heb jij vandaag geprogrammeerd? 2.0

Jessee schreef:

Eerdere citaten tonen

Dylan schreef:

Eerdere citaten tonen

Sjoerd schreef:

PHP class voor asynchrone http requests met curl.

Dit ga ik gebruiken voor de cronjob van Relisten (momenteel is die nogal traag )

(code)

Codeblok (MultiHandleCURL.php):

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



/**
* Class Logger
*/
class Logger {
/**
* @param string $message
*/
public static function log($message) {
print [.date(Y-m-d H:i:s) . ] . $message .
. PHP_EOL;
}
}

/**
* Class MultiHandleCURL
*/
class MultiHandleCURL {

/**
* @var resource
*/
private $multi_handle;
/**
* @var array
*/
private $callables = [];
/**
* @var int|null
*/
private $active = null;

/**
* MultiHandleCURL constructor.
*/
function __construct() {
$this->multi_handle = curl_multi_init();
if ($this->multi_handle === false) {
exit(cant create multi curl handle);
}
Logger::log(started MultiHandleCURL);
}

/**
* @param resource $ch
* @param callable|null $callable
*/
function addHandle($ch, $callable = null) {
$res = curl_multi_add_handle($this->multi_handle, $ch);
if ($callable != null) {
$this->callables[(int)$ch] = $callable;
}
if ($res === 0) {
Logger::log(added handle);
var_dump($ch);
$mrc = curl_multi_exec($this->multi_handle, $this->active);
} else {
Logger::log(Error at adding handle: . $res);
}
}

/**
* Finish performing requests
*/
function finishRequests() {
Logger::log(perform requests started!);
//execute the handles
do {
$mrc = curl_multi_exec($this->multi_handle, $this->active);
//Logger::log(curl_multi_exec returns . $mrc);
//Logger::log(curl_multi_exec sets active to . var_export($this->active, true));

$info = curl_multi_info_read($this->multi_handle);
if (false !== $info) {
Logger::log(multi info read result);
var_dump($info);

$output = curl_multi_getcontent($info[handle]);
Logger::log(output:);
var_dump($output);

if (isset($this->callables[(int)$info[handle]])) {
Logger::log(we roepen de callback functie aan!);
$callable = $this->callables[(int)$info[handle]];
var_dump($callable);
call_user_func($callable, $output);
}
curl_multi_remove_handle($this->multi_handle, $info[handle]);
curl_close($info[handle]);
}
} while ($mrc == CURLM_CALL_MULTI_PERFORM || $this->active);
Logger::log(perform requests finished!);
}

/**
*
*/
function __destruct() {
curl_multi_close($this->multi_handle);
Logger::log(destruct MultiHandleCURL);
}
}

/**
* Class Request
*/
abstract class Request {
/**
* @var resource
*/
protected $multiHandle;
/**
* @var string
*/
protected $url;
/**
* @var int
*/
private $timeout = 5;

/**
* Request constructor.
* @param string $url
*/
public function __construct($url) {
$this->url = $url;
}

/**
* @param resource $multiHandle
*/
public function setMultiHandleCURL($multiHandle) {
$this->multiHandle = $multiHandle;
}

/**
*
*/
public function executeRequest() {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $this->url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $this->timeout);
curl_setopt($ch, CURLOPT_TIMEOUT, $this->timeout);
curl_setopt($ch, CURLOPT_HEADER, 1);

$this->multiHandle->addHandle($ch, array($this, handleResponse));
}

/**
* @param $output
* @return void
*/
public abstract function handleResponse($output);
}

// Test gedeelte vanaf hier. Test is geslaagd als de drie requests uitgevoerd zijn en hun output geprint etc.

/**
* Class Request1
*/
class Request1 extends Request {
/**
* @param string $output
*/
public function handleResponse($output) {
Logger::log(substr($output, 0, 10));
}
}

/**
* Class Request2
*/
class Request2 extends Request {
/**
* @param string $output
*/
public function handleResponse($output) {
Logger::log(substr($output, 0, 40));

$request = new Request3($this->url);
$request->setMultiHandleCURL($this->multiHandle);
$request->executeRequest();
}
}

/**
* Class Request3
*/
class Request3 extends Request {
/**
* @param string $output
*/
public function handleResponse($output) {
Logger::log(substr($output, 0, 15));
}
}

$multiHandle = new MultiHandleCURL();

$request1 = new Request1(http://www.example.com/);
$request1->setMultiHandleCURL($multiHandle);
$request1->executeRequest();

$request1 = new Request2(http://www.example.net/);
$request1->setMultiHandleCURL($multiHandle);
$request1->executeRequest();

$multiHandle->finishRequests();

gebruik ook
curl_setopt($ch, CURLOPT_USERAGENT, Mozilla/5.001 (windows; U; NT4.0; en-US; rv:1.0) Gecko/25250101);

Geef dan ook direct een reden.

Sometimes the user agent will change how a site responds, may need to do something like:
http://stackoverflow.com/questions/1937188/curl-really-slow

Dylan schreef:

Eerdere citaten tonen

Sjoerd schreef:

PHP class voor asynchrone http requests met curl.

Dit ga ik gebruiken voor de cronjob van Relisten (momenteel is die nogal traag )

(code)

Codeblok (MultiHandleCURL.php):

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



/**
* Class Logger
*/
class Logger {
/**
* @param string $message
*/
public static function log($message) {
print [.date(Y-m-d H:i:s) . ] . $message .
. PHP_EOL;
}
}

/**
* Class MultiHandleCURL
*/
class MultiHandleCURL {

/**
* @var resource
*/
private $multi_handle;
/**
* @var array
*/
private $callables = [];
/**
* @var int|null
*/
private $active = null;

/**
* MultiHandleCURL constructor.
*/
function __construct() {
$this->multi_handle = curl_multi_init();
if ($this->multi_handle === false) {
exit(cant create multi curl handle);
}
Logger::log(started MultiHandleCURL);
}

/**
* @param resource $ch
* @param callable|null $callable
*/
function addHandle($ch, $callable = null) {
$res = curl_multi_add_handle($this->multi_handle, $ch);
if ($callable != null) {
$this->callables[(int)$ch] = $callable;
}
if ($res === 0) {
Logger::log(added handle);
var_dump($ch);
$mrc = curl_multi_exec($this->multi_handle, $this->active);
} else {
Logger::log(Error at adding handle: . $res);
}
}

/**
* Finish performing requests
*/
function finishRequests() {
Logger::log(perform requests started!);
//execute the handles
do {
$mrc = curl_multi_exec($this->multi_handle, $this->active);
//Logger::log(curl_multi_exec returns . $mrc);
//Logger::log(curl_multi_exec sets active to . var_export($this->active, true));

$info = curl_multi_info_read($this->multi_handle);
if (false !== $info) {
Logger::log(multi info read result);
var_dump($info);

$output = curl_multi_getcontent($info[handle]);
Logger::log(output:);
var_dump($output);

if (isset($this->callables[(int)$info[handle]])) {
Logger::log(we roepen de callback functie aan!);
$callable = $this->callables[(int)$info[handle]];
var_dump($callable);
call_user_func($callable, $output);
}
curl_multi_remove_handle($this->multi_handle, $info[handle]);
curl_close($info[handle]);
}
} while ($mrc == CURLM_CALL_MULTI_PERFORM || $this->active);
Logger::log(perform requests finished!);
}

/**
*
*/
function __destruct() {
curl_multi_close($this->multi_handle);
Logger::log(destruct MultiHandleCURL);
}
}

/**
* Class Request
*/
abstract class Request {
/**
* @var resource
*/
protected $multiHandle;
/**
* @var string
*/
protected $url;
/**
* @var int
*/
private $timeout = 5;

/**
* Request constructor.
* @param string $url
*/
public function __construct($url) {
$this->url = $url;
}

/**
* @param resource $multiHandle
*/
public function setMultiHandleCURL($multiHandle) {
$this->multiHandle = $multiHandle;
}

/**
*
*/
public function executeRequest() {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $this->url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $this->timeout);
curl_setopt($ch, CURLOPT_TIMEOUT, $this->timeout);
curl_setopt($ch, CURLOPT_HEADER, 1);

$this->multiHandle->addHandle($ch, array($this, handleResponse));
}

/**
* @param $output
* @return void
*/
public abstract function handleResponse($output);
}

// Test gedeelte vanaf hier. Test is geslaagd als de drie requests uitgevoerd zijn en hun output geprint etc.

/**
* Class Request1
*/
class Request1 extends Request {
/**
* @param string $output
*/
public function handleResponse($output) {
Logger::log(substr($output, 0, 10));
}
}

/**
* Class Request2
*/
class Request2 extends Request {
/**
* @param string $output
*/
public function handleResponse($output) {
Logger::log(substr($output, 0, 40));

$request = new Request3($this->url);
$request->setMultiHandleCURL($this->multiHandle);
$request->executeRequest();
}
}

/**
* Class Request3
*/
class Request3 extends Request {
/**
* @param string $output
*/
public function handleResponse($output) {
Logger::log(substr($output, 0, 15));
}
}

$multiHandle = new MultiHandleCURL();

$request1 = new Request1(http://www.example.com/);
$request1->setMultiHandleCURL($multiHandle);
$request1->executeRequest();

$request1 = new Request2(http://www.example.net/);
$request1->setMultiHandleCURL($multiHandle);
$request1->executeRequest();

$multiHandle->finishRequests();

gebruik ook
curl_setopt($ch, CURLOPT_USERAGENT, Mozilla/5.001 (windows; U; NT4.0; en-US; rv:1.0) Gecko/25250101);

Die request class is gebruikt voor testing. In productie gebruik ik in sommige gevallen inderdaad een useragent, maar dat is bij de meeste APIs die ik gebruik overbodig.

Sevvlor schreef:

@sjoerd ik neem aan dat de vraag is: "hoe maak ik hem sneller?"

Ik ga er van uit dat de cronjob al sneller werkt als ik deze class ga gebruiken. Momenteel zijn de requests nog blocking, waardoor de cronjob een redelijk hoge executietijd heeft als het soms wel meer dan 1 seconde voor sommige requests duurt.

Sjoerd schreef:

Eerdere citaten tonen

Dylan schreef:

Eerdere citaten tonen

Sjoerd schreef:

PHP class voor asynchrone http requests met curl.

Dit ga ik gebruiken voor de cronjob van Relisten (momenteel is die nogal traag )

(code)

Codeblok (MultiHandleCURL.php):

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



/**
* Class Logger
*/
class Logger {
/**
* @param string $message
*/
public static function log($message) {
print [.date(Y-m-d H:i:s) . ] . $message .
. PHP_EOL;
}
}

/**
* Class MultiHandleCURL
*/
class MultiHandleCURL {

/**
* @var resource
*/
private $multi_handle;
/**
* @var array
*/
private $callables = [];
/**
* @var int|null
*/
private $active = null;

/**
* MultiHandleCURL constructor.
*/
function __construct() {
$this->multi_handle = curl_multi_init();
if ($this->multi_handle === false) {
exit(cant create multi curl handle);
}
Logger::log(started MultiHandleCURL);
}

/**
* @param resource $ch
* @param callable|null $callable
*/
function addHandle($ch, $callable = null) {
$res = curl_multi_add_handle($this->multi_handle, $ch);
if ($callable != null) {
$this->callables[(int)$ch] = $callable;
}
if ($res === 0) {
Logger::log(added handle);
var_dump($ch);
$mrc = curl_multi_exec($this->multi_handle, $this->active);
} else {
Logger::log(Error at adding handle: . $res);
}
}

/**
* Finish performing requests
*/
function finishRequests() {
Logger::log(perform requests started!);
//execute the handles
do {
$mrc = curl_multi_exec($this->multi_handle, $this->active);
//Logger::log(curl_multi_exec returns . $mrc);
//Logger::log(curl_multi_exec sets active to . var_export($this->active, true));

$info = curl_multi_info_read($this->multi_handle);
if (false !== $info) {
Logger::log(multi info read result);
var_dump($info);

$output = curl_multi_getcontent($info[handle]);
Logger::log(output:);
var_dump($output);

if (isset($this->callables[(int)$info[handle]])) {
Logger::log(we roepen de callback functie aan!);
$callable = $this->callables[(int)$info[handle]];
var_dump($callable);
call_user_func($callable, $output);
}
curl_multi_remove_handle($this->multi_handle, $info[handle]);
curl_close($info[handle]);
}
} while ($mrc == CURLM_CALL_MULTI_PERFORM || $this->active);
Logger::log(perform requests finished!);
}

/**
*
*/
function __destruct() {
curl_multi_close($this->multi_handle);
Logger::log(destruct MultiHandleCURL);
}
}

/**
* Class Request
*/
abstract class Request {
/**
* @var resource
*/
protected $multiHandle;
/**
* @var string
*/
protected $url;
/**
* @var int
*/
private $timeout = 5;

/**
* Request constructor.
* @param string $url
*/
public function __construct($url) {
$this->url = $url;
}

/**
* @param resource $multiHandle
*/
public function setMultiHandleCURL($multiHandle) {
$this->multiHandle = $multiHandle;
}

/**
*
*/
public function executeRequest() {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $this->url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $this->timeout);
curl_setopt($ch, CURLOPT_TIMEOUT, $this->timeout);
curl_setopt($ch, CURLOPT_HEADER, 1);

$this->multiHandle->addHandle($ch, array($this, handleResponse));
}

/**
* @param $output
* @return void
*/
public abstract function handleResponse($output);
}

// Test gedeelte vanaf hier. Test is geslaagd als de drie requests uitgevoerd zijn en hun output geprint etc.

/**
* Class Request1
*/
class Request1 extends Request {
/**
* @param string $output
*/
public function handleResponse($output) {
Logger::log(substr($output, 0, 10));
}
}

/**
* Class Request2
*/
class Request2 extends Request {
/**
* @param string $output
*/
public function handleResponse($output) {
Logger::log(substr($output, 0, 40));

$request = new Request3($this->url);
$request->setMultiHandleCURL($this->multiHandle);
$request->executeRequest();
}
}

/**
* Class Request3
*/
class Request3 extends Request {
/**
* @param string $output
*/
public function handleResponse($output) {
Logger::log(substr($output, 0, 15));
}
}

$multiHandle = new MultiHandleCURL();

$request1 = new Request1(http://www.example.com/);
$request1->setMultiHandleCURL($multiHandle);
$request1->executeRequest();

$request1 = new Request2(http://www.example.net/);
$request1->setMultiHandleCURL($multiHandle);
$request1->executeRequest();

$multiHandle->finishRequests();

gebruik ook
curl_setopt($ch, CURLOPT_USERAGENT, Mozilla/5.001 (windows; U; NT4.0; en-US; rv:1.0) Gecko/25250101);

Die request class is gebruikt voor testing. In productie gebruik ik in sommige gevallen inderdaad een useragent, maar dat is bij de meeste APIs die ik gebruik overbodig.

Sevvlor schreef:

@sjoerd ik neem aan dat de vraag is: "hoe maak ik hem sneller?"

Ik ga er van uit dat de cronjob al sneller werkt als ik deze class ga gebruiken. Momenteel zijn de requests nog blocking, waardoor de cronjob een redelijk hoge executietijd heeft als het soms wel meer dan 1 seconde voor sommige requests duurt.

Kan je niet gewoon beter een Java programmeren met multi threads

Dylan schreef:

Eerdere citaten tonen

Sjoerd schreef:

Eerdere citaten tonen

Dylan schreef:

Eerdere citaten tonen

Sjoerd schreef:

PHP class voor asynchrone http requests met curl.

Dit ga ik gebruiken voor de cronjob van Relisten (momenteel is die nogal traag )

(code)

Codeblok (MultiHandleCURL.php):

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



/**
* Class Logger
*/
class Logger {
/**
* @param string $message
*/
public static function log($message) {
print [.date(Y-m-d H:i:s) . ] . $message .
. PHP_EOL;
}
}

/**
* Class MultiHandleCURL
*/
class MultiHandleCURL {

/**
* @var resource
*/
private $multi_handle;
/**
* @var array
*/
private $callables = [];
/**
* @var int|null
*/
private $active = null;

/**
* MultiHandleCURL constructor.
*/
function __construct() {
$this->multi_handle = curl_multi_init();
if ($this->multi_handle === false) {
exit(cant create multi curl handle);
}
Logger::log(started MultiHandleCURL);
}

/**
* @param resource $ch
* @param callable|null $callable
*/
function addHandle($ch, $callable = null) {
$res = curl_multi_add_handle($this->multi_handle, $ch);
if ($callable != null) {
$this->callables[(int)$ch] = $callable;
}
if ($res === 0) {
Logger::log(added handle);
var_dump($ch);
$mrc = curl_multi_exec($this->multi_handle, $this->active);
} else {
Logger::log(Error at adding handle: . $res);
}
}

/**
* Finish performing requests
*/
function finishRequests() {
Logger::log(perform requests started!);
//execute the handles
do {
$mrc = curl_multi_exec($this->multi_handle, $this->active);
//Logger::log(curl_multi_exec returns . $mrc);
//Logger::log(curl_multi_exec sets active to . var_export($this->active, true));

$info = curl_multi_info_read($this->multi_handle);
if (false !== $info) {
Logger::log(multi info read result);
var_dump($info);

$output = curl_multi_getcontent($info[handle]);
Logger::log(output:);
var_dump($output);

if (isset($this->callables[(int)$info[handle]])) {
Logger::log(we roepen de callback functie aan!);
$callable = $this->callables[(int)$info[handle]];
var_dump($callable);
call_user_func($callable, $output);
}
curl_multi_remove_handle($this->multi_handle, $info[handle]);
curl_close($info[handle]);
}
} while ($mrc == CURLM_CALL_MULTI_PERFORM || $this->active);
Logger::log(perform requests finished!);
}

/**
*
*/
function __destruct() {
curl_multi_close($this->multi_handle);
Logger::log(destruct MultiHandleCURL);
}
}

/**
* Class Request
*/
abstract class Request {
/**
* @var resource
*/
protected $multiHandle;
/**
* @var string
*/
protected $url;
/**
* @var int
*/
private $timeout = 5;

/**
* Request constructor.
* @param string $url
*/
public function __construct($url) {
$this->url = $url;
}

/**
* @param resource $multiHandle
*/
public function setMultiHandleCURL($multiHandle) {
$this->multiHandle = $multiHandle;
}

/**
*
*/
public function executeRequest() {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $this->url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $this->timeout);
curl_setopt($ch, CURLOPT_TIMEOUT, $this->timeout);
curl_setopt($ch, CURLOPT_HEADER, 1);

$this->multiHandle->addHandle($ch, array($this, handleResponse));
}

/**
* @param $output
* @return void
*/
public abstract function handleResponse($output);
}

// Test gedeelte vanaf hier. Test is geslaagd als de drie requests uitgevoerd zijn en hun output geprint etc.

/**
* Class Request1
*/
class Request1 extends Request {
/**
* @param string $output
*/
public function handleResponse($output) {
Logger::log(substr($output, 0, 10));
}
}

/**
* Class Request2
*/
class Request2 extends Request {
/**
* @param string $output
*/
public function handleResponse($output) {
Logger::log(substr($output, 0, 40));

$request = new Request3($this->url);
$request->setMultiHandleCURL($this->multiHandle);
$request->executeRequest();
}
}

/**
* Class Request3
*/
class Request3 extends Request {
/**
* @param string $output
*/
public function handleResponse($output) {
Logger::log(substr($output, 0, 15));
}
}

$multiHandle = new MultiHandleCURL();

$request1 = new Request1(http://www.example.com/);
$request1->setMultiHandleCURL($multiHandle);
$request1->executeRequest();

$request1 = new Request2(http://www.example.net/);
$request1->setMultiHandleCURL($multiHandle);
$request1->executeRequest();

$multiHandle->finishRequests();

gebruik ook
curl_setopt($ch, CURLOPT_USERAGENT, Mozilla/5.001 (windows; U; NT4.0; en-US; rv:1.0) Gecko/25250101);

Die request class is gebruikt voor testing. In productie gebruik ik in sommige gevallen inderdaad een useragent, maar dat is bij de meeste APIs die ik gebruik overbodig.

Sevvlor schreef:

@sjoerd ik neem aan dat de vraag is: "hoe maak ik hem sneller?"

Ik ga er van uit dat de cronjob al sneller werkt als ik deze class ga gebruiken. Momenteel zijn de requests nog blocking, waardoor de cronjob een redelijk hoge executietijd heeft als het soms wel meer dan 1 seconde voor sommige requests duurt.

Kan je niet gewoon beter een Java programmeren met multi threads

Dan moet ik een aparte server draaiend houden speciaal daarvoor. Nu zit alles lekker vertrouwd bij elkaar op server 3

en boek een hotel, das gewoon copy paste

dit is deel 1 van het project, volgende delen gaat over winkelwagen, factuur en boeken ofzo.

Heb komende 7 weken dus weer lekker veel vrij

https://github.com/dazdylz/jQuery-inputEditor

Let niet op mijn Engels, moet ik nog verbeteren

fibonacci sequence in mijn lisp

toevoeging op 12 februari 2016, 21:26:09:
En de eerste pull request van iemand anders ontvangen

Zitten debuggen met jQuery(ui)-libraries. Bij de ene versie werkte de ene add-on wel, en bij de andere de andere weer niet. En kreeg ik weer andere spannende bij-effecten die nergens op sloegen.

Uiteindelijk maar de laatste jQuery stable uit de 1.* branche gebruikt. Wel raar dat Fancybox2 niet werkt onder jQuery2?

Mijn eerste Java spam-programmaatje gemaakt
Werkt met Whatsapp Web en Skype etc.

(alleen extra informatie is nog hardcoded)

stukje code:

Codeblok (voorbeeld.php):

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

app.controller("winkelCntrl", ["$scope", "shoppingCart", function($scope, $shoppingCart) {
function sumPrice() {
return $scope.items
.map(function(i) {
// array moet alleen bestaan uit de prijzen (prijs * aantal)
return i.information[0].price * i.details.amount;
})
.reduce(function(a, b) {
// verklein de array door alles bij elkaar op te tellen
return parseFloat(a + b);
}, 0);
}

$scope.items = $shoppingCart.products;

$scope.sumPrice = sumPrice();

$scope.deleteProduct = function(product) {
$shoppingCart.deleteProduct(product);
$scope.items = $shoppingCart.products;

$scope.sumPrice = sumPrice();

}
}]);

Nice gebruik van map/reduce.
toevoeging op 16 februari 2016, 20:22:22:
Als meer mensen functional programming constructs gebruiken zou code er veel beter uit zien

Mijn server MoniTor afgemaakt. Kan vanaf de remote de server stats checken en commands sturen . (Commands = voor gedefinieerde scripts die hij als taak kan uitvoeren met een X interval). Nieuwe servers melden zich vanzelf aan op de pool

Schoolopdracht
Codeblok (voorbeeld.php):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23





php is stupid

Codeblok (voorbeeld.php):

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

// no jquery

(function(document) {
var i = document.getElementsByName("i")[0],
j = document.getElementsByName("j")[0],
n = document.getElementsByName("n")[0],
c = document.getElementsByName("c")[0],
r = document.getElementById("result"),
b = document.getElementsByName("button")[0];

var calculate = function() {
var a = [],
b = [],

valI = i.value,
valJ = j.value;

for(; valI > 0; valI--) a.push(_.random(0, j.value))
for(; valJ > 0; valJ--) b.push(_.random(0, valJ))

return _.shuffle(
_.unique(
_.difference(a, b)
)
)
.slice(c.value, n.value);
},

display = function() {
r.innerHTML = "Result: [" + calculate().join() + "]";
}

// when i changed, change to max value for j
i.addEventListener("change", function() {
j.max = this.value;

if(j.value > this.value) j.value = this.value;
if(n.value > j.value) n.value = j.value;
});

j.addEventListener("change", function() {
n.max = this.value;
if(n.value > this.value) n.value = this.value;
});

b.addEventListener("click", display);
})(document);

opdracht was om gebruik te maken van [c]$.post[/c] die het PHP script van de vorige opdracht aanriep

Een paar tooltjes in PHP om treinstellen makkelijk en snel te kunnen zoeken, voor (nog?) eigen gebruik.

Op mijn stage gisteren verder gegaan met een forum van mij herschrijven in Laravel. Bijna alle migrations en models (met relaties) zijn nu in orde. Moet alleen nog kijken naar het hele gelezen/ongelezen gedeelte van de applicatie, maar heb daar ook al een hoop voorbereidingen op gedaan.