WEBVTT

1
00:00.000 --> 00:03.520
So in the previous video, you wrote a playbook that would ultimately monitor

2
00:03.520 --> 00:04.880
the memory utilization

3
00:04.880 --> 00:09.440
or rather the free memory on the devices that we were managing. Now in this

4
00:09.440 --> 00:10.320
particular video,

5
00:10.320 --> 00:13.420
I want to do something very, very similar, meaning that we're going to be

6
00:13.420 --> 00:14.640
monitoring memory once

7
00:14.640 --> 00:19.830
again, but I want to focus particularly on managing the numerical values so

8
00:19.830 --> 00:21.280
that we can actually run

9
00:21.280 --> 00:25.360
tests against particular values. Now what on earth am I even talking about here

10
00:25.360 --> 00:26.240
? This sounds

11
00:26.240 --> 00:29.630
super abstract. Well it really isn't. We're going to be talking about this

12
00:29.630 --> 00:30.960
concept of integers
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

12
00:29.630 --> 00:30.960
concept of integers

13
00:30.960 --> 00:34.740
again, all the values of floats and how they happen to be different from what

14
00:34.740 --> 00:35.600
are known as

15
00:35.600 --> 00:40.790
string values in programming languages and how this can actually affect us when

16
00:40.790 --> 00:41.760
we want to make

17
00:41.760 --> 00:45.180
comparisons. Let me tell you what I mean. So generally within a programming

18
00:45.180 --> 00:45.680
language,

19
00:45.680 --> 00:49.670
you'll have a very particular way to specify what is known as a string value.

20
00:49.670 --> 00:50.160
And commonly,

21
00:50.160 --> 00:54.320
this might be to use quotation marks. If I said the name john, this would be a

22
00:54.320 --> 00:55.600
string value. Basically,

23
00:55.600 --> 00:59.850
it's just like a word. Okay, whereas if I wanted to use in America values, such

24
00:59.850 --> 01:00.880
as the number four,
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

24
00:59.850 --> 01:00.880
as the number four,

25
01:00.880 --> 01:04.640
in the case of let's say they say the Python programming language to specify

26
01:04.640 --> 01:05.280
that this is an

27
01:05.280 --> 01:09.910
integer and not a string, you would not have your quotation marks. So what is

28
01:09.910 --> 01:10.560
that that is the

29
01:10.560 --> 01:14.330
relevance of this? How does this affect things? Well, let's maybe say we want

30
01:14.330 --> 01:15.760
to run a comparison. Okay,

31
01:15.760 --> 01:19.710
so let's say you had this year four, but you had it in quotation marks so that

32
01:19.710 --> 01:20.960
it was denoted as a

33
01:20.960 --> 01:26.150
string value. If you try to do some type of mathematical operation using the

34
01:26.150 --> 01:26.960
plus symbol,

35
01:26.960 --> 01:30.920
and you added in yet another string value, such as five with in quotation marks
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

35
01:26.960 --> 01:30.920
and you added in yet another string value, such as five with in quotation marks

36
01:30.920 --> 01:31.760
, these would be

37
01:31.760 --> 01:35.720
interpreted as characters and not actually as a numerical value. So if we add

38
01:35.720 --> 01:37.120
these two together,

39
01:37.120 --> 01:40.480
what do you think you would get? You're actually not going to get the value

40
01:40.480 --> 01:40.880
nine,

41
01:40.880 --> 01:45.000
you would get the value, the string value that is four and five, which might

42
01:45.000 --> 01:46.320
look like 45,

43
01:46.320 --> 01:49.520
very, very different from adding four and five together. Similarly, if you

44
01:49.520 --> 01:50.480
wanted to have a

45
01:50.480 --> 01:54.030
variable, let's say you registered the variable, maybe some memory output and

46
01:54.030 --> 01:54.720
it came out at the

47
01:54.720 --> 01:59.140
value of let's maybe say 32, if you wanted to run a comparison and say, hey, if

48
01:59.140 --> 02:00.400
the number is below
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

48
01:59.140 --> 02:00.400
the number is below

49
02:00.400 --> 02:05.730
50%, so less than 50%, then you would want to effectively shoot off some type

50
02:05.730 --> 02:06.480
of message,

51
02:06.480 --> 02:10.780
some type of alerts and hey, the value is lower than expected. Now in order for

52
02:10.780 --> 02:11.680
this comparison

53
02:11.680 --> 02:16.620
to operate, these actually have to be acting as integers or floats rather than

54
02:16.620 --> 02:17.840
string values.

55
02:17.840 --> 02:20.360
This is what I'm talking about here. So what I just want to do is I want to

56
02:20.360 --> 02:21.600
briefly take a moment

57
02:21.600 --> 02:26.240
to perhaps run a command that is going to pull some memory statistics and then

58
02:26.240 --> 02:30.110
manipulate those values so that we can ensure that the data is coming back as
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

58
02:26.240 --> 02:30.110
manipulate those values so that we can ensure that the data is coming back as

59
02:30.110 --> 02:31.040
numerical values

60
02:31.040 --> 02:35.630
integers so that we can effectively do our tests. So let's go and see how this

61
02:35.630 --> 02:36.960
actually shakes out

62
02:36.960 --> 02:39.930
them. So what I will do here is I'll create a new playbook. Let's call this

63
02:39.930 --> 02:40.720
play two dot y

64
02:40.720 --> 02:44.440
melgrons and set more to have our three hyphens at the top and we'll get this

65
02:44.440 --> 02:45.440
play-bicker name,

66
02:45.440 --> 02:51.280
we'll call it play two and we'll just say testing memory values. So if I target

67
02:51.280 --> 02:52.080
the host of the

68
02:52.080 --> 02:55.680
all which is going to be every device in my inventory and I set my gather facts

69
02:55.680 --> 02:55.920
to be the

70
02:55.920 --> 03:00.590
billion value of false, I can now define my tasks. Now what I'm going to do
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

70
02:55.920 --> 03:00.590
billion value of false, I can now define my tasks. Now what I'm going to do

71
03:00.590 --> 03:01.600
here is I'll give this

72
03:01.600 --> 03:06.350
first tasking name and I'll just say retrieve free memory. So let me use the

73
03:06.350 --> 03:07.760
Ansible built-in shell

74
03:07.760 --> 03:11.230
module. Now this is the command that I want to run here. If I just happened to

75
03:11.230 --> 03:12.320
let's maybe cat

76
03:12.320 --> 03:16.970
the proc mem info file right here, we're going to get a whole bunch of memory

77
03:16.970 --> 03:17.840
statistics. We see

78
03:17.840 --> 03:22.400
this. Okay, let's scroll on up. So what I want to do here is I want to get the

79
03:22.400 --> 03:24.000
amount of free memory

80
03:24.000 --> 03:28.020
which is this value right here. So what I can do is I can just write for that

81
03:28.020 --> 03:28.960
directly. So let's

82
03:28.960 --> 03:32.810
move this here and I'll just say grip for mem free and be careful of the
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

82
03:28.960 --> 03:32.810
move this here and I'll just say grip for mem free and be careful of the

83
03:32.810 --> 03:34.560
capitalization. If I hit

84
03:34.560 --> 03:39.050
enter right now, look at what we're getting back. So let's go and try to use

85
03:39.050 --> 03:40.160
this particular

86
03:40.160 --> 03:45.190
value then. So let's go in here and grab this particular command. Okay, copy

87
03:45.190 --> 03:46.240
you right click.

88
03:46.240 --> 03:50.480
There we go. Back into the playbook going to insert mode and all I will do here

89
03:50.480 --> 03:51.200
is I'll just

90
03:51.200 --> 03:54.770
paste in this particular command. Now what I want to now do is I want to

91
03:54.770 --> 03:56.240
register the output as a

92
03:56.240 --> 04:00.940
variable so we can actually use it. And let's just save this as free memory. So
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

92
03:56.240 --> 04:00.940
variable so we can actually use it. And let's just save this as free memory. So

93
04:00.940 --> 04:01.520
right now what I'm

94
04:01.520 --> 04:04.910
going to do here is I'm going to just print the value and I'll use the Ansible

95
04:04.910 --> 04:06.320
built in debug module

96
04:06.320 --> 04:10.590
and let's pass in the message with my double quotation marks and my double

97
04:10.590 --> 04:11.280
curly braces and

98
04:11.280 --> 04:15.660
I'll just pass in the free underscore memory variable. Check this out. So let's

99
04:15.660 --> 04:16.800
see how this goes in.

100
04:16.800 --> 04:21.730
If I clear the screen, I say Ansible Playbook play 2.YML and to enter. Oh, of

101
04:21.730 --> 04:22.720
course, let me go back

102
04:22.720 --> 04:27.200
into the playbook. And for now going to insert mode and I'll just print the STD

103
04:27.200 --> 04:28.000
out. Okay, so we just

104
04:28.000 --> 04:31.400
get the standard out and not all this extraneous information. So let's rerun it
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

104
04:28.000 --> 04:31.400
get the standard out and not all this extraneous information. So let's rerun it

105
04:31.400 --> 04:32.640
again. Cool. So let's

106
04:32.640 --> 04:35.460
look at what we see here. We have this string value. You see this with our

107
04:35.460 --> 04:37.040
quotation marks. Now,

108
04:37.040 --> 04:42.070
what we want to do is we want to get just this numerical value. So ultimately

109
04:42.070 --> 04:43.360
we want to split

110
04:43.360 --> 04:47.680
the outputs. Now effectively, there are three components that we can see here.

111
04:47.680 --> 04:48.880
We have this part

112
04:48.880 --> 04:53.600
here, then we have some space, and then we have this part here, and then again,

113
04:53.600 --> 04:54.640
a little bit of space,

114
04:54.640 --> 04:59.030
and then at the end, and then the size of the kilobytes. Now, what we want to

115
04:59.030 --> 05:00.160
be able to do is to
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

115
04:59.030 --> 05:00.160
be able to do is to

116
05:00.160 --> 05:04.050
actually isolate these three components or break them up. So we have access to

117
05:04.050 --> 05:05.520
each one individually,

118
05:05.520 --> 05:09.390
and then we can choose just the numerical value that we want to get. Now the

119
05:09.390 --> 05:10.320
way we can do this is

120
05:10.320 --> 05:14.510
by using a very particular method with thin Ansible. And this is known as the

121
05:14.510 --> 05:15.840
split command. So let

122
05:15.840 --> 05:19.460
me show you how this actually operates them. Okay, if I go back into my

123
05:19.460 --> 05:20.800
playbook right here,

124
05:20.800 --> 05:26.430
and when I take the STD out, if I just say split and then parentheses, I'm

125
05:26.430 --> 05:27.200
effectively going to

126
05:27.200 --> 05:31.670
split the output every time we incur some white space, which should break into
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

126
05:27.200 --> 05:31.670
split the output every time we incur some white space, which should break into

127
05:31.670 --> 05:32.640
three different

128
05:32.640 --> 05:36.200
components. So let's see how this works now. Okay, run the playbook. Ah, look

129
05:36.200 --> 05:37.440
at this. We actually

130
05:37.440 --> 05:42.000
have an array object, see her square brackets. And inside of this, we have

131
05:42.000 --> 05:43.360
three separate values.

132
05:43.360 --> 05:47.200
We have the first element and the array, which is name free. We have the second

133
05:47.200 --> 05:47.840
element, which is

134
05:47.840 --> 05:51.640
the value. And then at the end, we actually have the units in this case here

135
05:51.640 --> 05:52.720
kilobytes. So we have

136
05:52.720 --> 05:56.410
this for the blue box as well as the yellow box. Now, because we actually have

137
05:56.410 --> 05:57.680
an array object here,

138
05:57.680 --> 06:02.540
recall how we actually access the constituent components, we access them via
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

138
05:57.680 --> 06:02.540
recall how we actually access the constituent components, we access them via

139
06:02.540 --> 06:04.240
their index position.

140
06:04.240 --> 06:09.600
Now the very first position here is not actually position number one. It's

141
06:09.600 --> 06:11.040
known as position number

142
06:11.040 --> 06:15.660
zero. So zero is going to correlate to the word main three position one is

143
06:15.660 --> 06:16.720
going to correlate to

144
06:16.720 --> 06:21.440
the number which in this case here is five three oh four three six for the

145
06:21.440 --> 06:22.720
yellow box and for the

146
06:22.720 --> 06:26.810
blue box that would be four four nine one five two. And the second position in

147
06:26.810 --> 06:27.920
the way is quite

148
06:27.920 --> 06:31.470
simple. Just going to display the unit which in this case here for both devices
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

148
06:27.920 --> 06:31.470
simple. Just going to display the unit which in this case here for both devices

149
06:31.470 --> 06:32.160
is kilobytes.

150
06:32.160 --> 06:36.080
What we want to do is we want to print out the second element, which is going

151
06:36.080 --> 06:36.800
to be in

152
06:36.800 --> 06:40.310
list position one. So let's see how this actually shapes out them. Let's go

153
06:40.310 --> 06:41.600
back in right after we

154
06:41.600 --> 06:46.120
split the output up. If we happen to go until it's maybe say this position zero

155
06:46.120 --> 06:47.120
and run the playbook,

156
06:47.120 --> 06:51.360
we just print out the word main three. Okay, then if we happen to print out

157
06:51.360 --> 06:52.640
list position two,

158
06:52.640 --> 06:56.880
you guessed it, what's going to happen? We're just going to see the word KB. So

159
06:56.880 --> 06:58.480
by deduction,

160
06:58.480 --> 07:02.850
if we grab less position one, we should actually get access to the numerical
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

160
06:58.480 --> 07:02.850
if we grab less position one, we should actually get access to the numerical

161
07:02.850 --> 07:03.680
value that we want to

162
07:03.680 --> 07:07.620
use. So check this out. Bam, there is a value five to eight four twenty for the

163
07:07.620 --> 07:08.640
yellow box and below

164
07:08.640 --> 07:12.990
for the blue box four four eight two four four now recall just because these

165
07:12.990 --> 07:14.160
look like numbers

166
07:14.160 --> 07:17.600
doesn't actually mean they're going to act like numbers are still going to be

167
07:17.600 --> 07:18.560
string values at

168
07:18.560 --> 07:22.380
the moment. Say for example, I wanted to perform a mathematical operation on

169
07:22.380 --> 07:23.360
this. So let's maybe

170
07:23.360 --> 07:27.050
say I go into my playbook. Let me grab this information here. I'll just move on

171
07:27.050 --> 07:27.840
to a new line for the

172
07:27.840 --> 07:33.440
moment. And instead, I'm going to have a message. And I'll just say free memory
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

172
07:27.840 --> 07:33.440
moment. And instead, I'm going to have a message. And I'll just say free memory

173
07:33.440 --> 07:35.840
is below 100 meg.

174
07:35.840 --> 07:39.900
And then what I'll do is I'll actually pass in the free memory value. Now

175
07:39.900 --> 07:40.960
temporarily, let me

176
07:40.960 --> 07:44.710
just comment this out for a moment. Okay, so no longer will this line have any

177
07:44.710 --> 07:45.840
effects. And in fact,

178
07:45.840 --> 07:49.640
before I do anything, let's make sure I'm printing the STD out. So right now if

179
07:49.640 --> 07:50.800
I run this playbook,

180
07:50.800 --> 07:54.810
we see here we're getting the message free memory is below 100 meg. And then we

181
07:54.810 --> 07:55.760
actually see the

182
07:55.760 --> 08:00.070
output of the value. Now the problem is right now is this line here is not
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

182
07:55.760 --> 08:00.070
output of the value. Now the problem is right now is this line here is not

183
08:00.070 --> 08:01.120
actually true.

184
08:01.120 --> 08:05.320
The free memory as we can see here is round about 400 meg. And in this case

185
08:05.320 --> 08:05.680
below,

186
08:05.680 --> 08:09.660
round about 500 meg. So basically, we don't want this particular message to

187
08:09.660 --> 08:10.000
print

188
08:10.000 --> 08:15.050
on less that condition is true. So the keyword here is condition. So we want to

189
08:15.050 --> 08:15.920
add in a conditional

190
08:15.920 --> 08:19.970
statement so we can use the when keyword. So let's go back into play to. And

191
08:19.970 --> 08:20.400
like I say,

192
08:20.400 --> 08:24.190
we don't want to print this command all the time. We only wanted to print it

193
08:24.190 --> 08:25.120
when a condition is

194
08:25.120 --> 08:29.760
true. So here is what I want to happen. I'm going to grab this information here

195
08:29.760 --> 08:30.560
, which we know is
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

195
08:29.760 --> 08:30.560
, which we know is

196
08:30.560 --> 08:34.920
going to isolate the numerical value alone. And I'm going to say is less than,

197
08:34.920 --> 08:36.720
let's say 100,000.

198
08:36.720 --> 08:40.460
Now watch this if I happen to save this right here. And I run the playbook, we

199
08:40.460 --> 08:41.120
're going to have a

200
08:41.120 --> 08:44.290
problem. Watch this, let's hit enter, check this out right here, look at the

201
08:44.290 --> 08:45.280
output. Let's grab

202
08:45.280 --> 08:49.180
this here for the blue box. We get an actual failure. And it says the

203
08:49.180 --> 08:50.640
conditional check free

204
08:50.640 --> 08:55.510
memory actually failed. And it says the error was an unexpected templating type

205
08:55.510 --> 08:56.720
error. So the issue

206
08:56.720 --> 09:02.080
is the type pretty much we can't use this comparison operator between instances
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

206
08:56.720 --> 09:02.080
is the type pretty much we can't use this comparison operator between instances

207
09:02.080 --> 09:02.640
of actual

208
09:02.640 --> 09:06.950
answerable text, which is basically our string value we're talking about and an

209
09:06.950 --> 09:08.000
integer value.

210
09:08.000 --> 09:12.560
So the problem is here, as if we go back in, is that where's this looks to the

211
09:12.560 --> 09:13.360
eye like it's a

212
09:13.360 --> 09:19.380
number, this particular value. It really is just answerable unsafe text, ie, it

213
09:19.380 --> 09:20.320
's just a string

214
09:20.320 --> 09:24.100
value. And it's been compared to in this case here an actual integer. So what

215
09:24.100 --> 09:24.720
we want to be able

216
09:24.720 --> 09:28.570
to do is you want to take this number that we've parsed out, which is still a

217
09:28.570 --> 09:29.520
string and then

218
09:29.520 --> 09:34.070
convert it to an integer. And then we can run the comparison against another
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

218
09:29.520 --> 09:34.070
convert it to an integer. And then we can run the comparison against another

219
09:34.070 --> 09:35.280
numerical value.

220
09:35.280 --> 09:38.710
So let's see how this is going to operate them. What I'm going to do is I'm

221
09:38.710 --> 09:39.520
going to go into

222
09:39.520 --> 09:43.840
insert mode here. I'm going to wrap this in parentheses right here. Okay. And

223
09:43.840 --> 09:44.720
what I'm going to do is

224
09:44.720 --> 09:49.550
I'm going to have a pipe symbol here. And I'm going to convert the value into

225
09:49.550 --> 09:50.880
an integer by using

226
09:50.880 --> 09:54.210
the int filter. So now let's check this out. Let's save this and see what

227
09:54.210 --> 09:55.520
happens. Let's run play

228
09:55.520 --> 09:59.760
to once again, let's hit enter. Aha, look at this right here. We don't get an

229
09:59.760 --> 10:00.960
error. All of this
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

229
09:59.760 --> 10:00.960
error. All of this

230
10:00.960 --> 10:05.040
happening is that we happen to be skipping the printing of the value because we

231
10:05.040 --> 10:06.240
're not actually

232
10:06.240 --> 10:10.880
below 100 meg of free memory. So just for the demonstration, what I can do is

233
10:10.880 --> 10:11.440
let me go to my

234
10:11.440 --> 10:17.010
blue box here. And what I will do is say pseudo DNF install stress hyphen

235
10:17.010 --> 10:17.680
engine,

236
10:17.680 --> 10:21.610
enter and type in my password here. Now what this is is a particular utility

237
10:21.610 --> 10:22.880
that is used to test

238
10:22.880 --> 10:26.630
your system. So let's say why and to enter. And what this is going to allow me

239
10:26.630 --> 10:27.440
to do is it's going

240
10:27.440 --> 10:31.430
to allow me to effectively choose the parameter that I want to really stress. I
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

240
10:27.440 --> 10:31.430
to allow me to effectively choose the parameter that I want to really stress. I

241
10:31.430 --> 10:32.080
can stress my

242
10:32.080 --> 10:36.640
memory. I can stress my input output. I can stress my CPU, that type of thing.

243
10:36.640 --> 10:37.840
So on the blue box,

244
10:37.840 --> 10:41.790
what I want to do is I want to run this program to really crank up my memory

245
10:41.790 --> 10:42.640
usage so that the

246
10:42.640 --> 10:48.520
free memory end that's becoming lower than 100 meg. So if I say stress ng dash

247
10:48.520 --> 10:49.840
dash VM two for two

248
10:49.840 --> 10:53.610
workers, the more workers I use the more stress you put in the system, I'll say

249
10:53.610 --> 10:55.120
dash dash VM bytes

250
10:55.120 --> 10:59.200
for the amount that I want to be using. And let's try to use one gig of memory.

251
10:59.200 --> 11:00.000
Okay, really stress
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

252
11:00.000 --> 11:05.940
the system. So if I open up a new tab and I say free dash h and to enter, we

253
11:05.940 --> 11:06.560
can see here the

254
11:06.560 --> 11:09.900
memory is gradually be getting lower. Let's run it again, getting lower again.

255
11:09.900 --> 11:10.720
So let's try to run

256
11:10.720 --> 11:15.000
our playbook right now. Let's add a what and to enter, look at this right here.

257
11:15.000 --> 11:15.520
In the case of

258
11:15.520 --> 11:19.080
the yellow box, because that was not stressed, we don't print out any value.

259
11:19.080 --> 11:19.920
But in the case of

260
11:19.920 --> 11:23.790
the blue box where we are running the stress test, we actually see here the

261
11:23.790 --> 11:25.280
free memory is now below

262
11:25.280 --> 11:30.280
100 meg and actually shows us here that the value is 77,000 k, which is again
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

262
11:25.280 --> 11:30.280
100 meg and actually shows us here that the value is 77,000 k, which is again

263
11:30.280 --> 11:31.600
below 100 meg. And

264
11:31.600 --> 11:35.490
that is because we can now run the comparison between this particular value

265
11:35.490 --> 11:36.880
that we passed out,

266
11:36.880 --> 11:41.200
converted to an integer and compared it to, if we go back into the playbook,

267
11:41.200 --> 11:41.360
then the

268
11:41.360 --> 11:46.410
miracle value here that we specify, which is going to denote 100 megabytes. So

269
11:46.410 --> 11:47.040
as you can see,

270
11:47.040 --> 11:50.210
it's very, very important to understand that the output that answer will give

271
11:50.210 --> 11:50.480
you,

272
11:50.480 --> 11:54.700
whilst it may look like numerical values, they may not actually be integers or

273
11:54.700 --> 11:56.000
floats, in which case,

274
11:56.000 --> 11:59.400
you're not going to be able to run your comparisons until you perform your

275
11:59.400 --> 12:00.080
conversions.
WEBVTT
X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000

275
11:59.400 --> 12:00.080
conversions.