View Javadoc

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    * 
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   * 
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  
18  package org.apache.log4j.rolling;
19  
20  import junit.framework.TestCase;
21  import org.apache.log4j.Appender;
22  import org.apache.log4j.ConsoleAppender;
23  import org.apache.log4j.LogManager;
24  import org.apache.log4j.Logger;
25  import org.apache.log4j.PatternLayout;
26  import org.apache.log4j.util.Compare;
27  
28  import java.io.File;
29  import java.io.FileOutputStream;
30  
31  
32  /***
33   *
34   * Do not forget to call activateOptions when configuring programatically.
35   * 
36   * @author Ceki Gülcü
37   *
38   */
39  public class SizeBasedRollingTest extends TestCase {
40    Logger logger = Logger.getLogger(SizeBasedRollingTest.class);
41    Logger root = Logger.getRootLogger();
42  
43    public SizeBasedRollingTest(String name) {
44      super(name);
45    }
46  
47    public void setUp() {
48      Appender ca = new ConsoleAppender(new PatternLayout("%d %level %c -%m%n"));
49      ca.setName("CONSOLE");
50      root.addAppender(ca);    
51    }
52  
53    public void tearDown() {
54      LogManager.shutdown();
55    }
56  
57      /***
58       * Tests that the lack of an explicit active file will use the
59       * low index as the active file.
60       *
61       */
62    public void test1() throws Exception {
63          PatternLayout layout = new PatternLayout("%m\n");
64          RollingFileAppender rfa = new RollingFileAppender();
65          rfa.setName("ROLLING");
66          rfa.setAppend(false);
67          rfa.setLayout(layout);
68  
69          FixedWindowRollingPolicy swrp = new FixedWindowRollingPolicy();
70          SizeBasedTriggeringPolicy sbtp = new SizeBasedTriggeringPolicy();
71  
72          sbtp.setMaxFileSize(100);
73          swrp.setMinIndex(0);
74  
75          swrp.setFileNamePattern("sizeBased-test1.%i");
76          swrp.activateOptions();
77  
78          rfa.setRollingPolicy(swrp);
79          rfa.setTriggeringPolicy(sbtp);
80          rfa.activateOptions();
81          root.addAppender(rfa);
82  
83          // Write exactly 10 bytes with each log
84          for (int i = 0; i < 25; i++) {
85            if (i < 10) {
86              logger.debug("Hello---" + i);
87            } else if (i < 100) {
88              logger.debug("Hello--" + i);
89            }
90          }
91  
92          assertTrue(new File("sizeBased-test1.0").exists());
93          assertTrue(new File("sizeBased-test1.1").exists());
94          assertTrue(new File("sizeBased-test1.2").exists());
95  
96          assertTrue(Compare.compare(SizeBasedRollingTest.class,
97                  "sizeBased-test1.0",
98           "witness/rolling/sbr-test2.log"));
99          assertTrue(Compare.compare(SizeBasedRollingTest.class,
100                 "sizeBased-test1.1",
101          "witness/rolling/sbr-test2.0"));
102         assertTrue(Compare.compare(SizeBasedRollingTest.class,
103                 "sizeBased-test1.2",
104          "witness/rolling/sbr-test2.1"));
105   }
106 
107     /*** 
108      * Test basic rolling functionality with explicit setting of FileAppender.file.
109      */ 
110   public void test2() throws Exception {
111     PatternLayout layout = new PatternLayout("%m\n");
112     RollingFileAppender rfa = new RollingFileAppender();
113     rfa.setName("ROLLING");
114     rfa.setAppend(false);
115     rfa.setLayout(layout);
116     rfa.setFile("sizeBased-test2.log");
117 
118     FixedWindowRollingPolicy swrp = new FixedWindowRollingPolicy();
119     SizeBasedTriggeringPolicy sbtp = new SizeBasedTriggeringPolicy();
120 
121     sbtp.setMaxFileSize(100);
122     swrp.setMinIndex(0);
123 
124     swrp.setFileNamePattern("sizeBased-test2.%i");
125     swrp.activateOptions();
126     
127     rfa.setRollingPolicy(swrp);
128     rfa.setTriggeringPolicy(sbtp);
129     rfa.activateOptions();
130     root.addAppender(rfa);
131 
132     // Write exactly 10 bytes with each log
133     for (int i = 0; i < 25; i++) {
134       if (i < 10) {
135         logger.debug("Hello---" + i);
136       } else if (i < 100) {
137         logger.debug("Hello--" + i);
138       }
139     }
140 
141     assertTrue(new File("sizeBased-test2.log").exists());
142     assertTrue(new File("sizeBased-test2.0").exists());
143     assertTrue(new File("sizeBased-test2.1").exists());
144 
145     assertTrue(Compare.compare(SizeBasedRollingTest.class,
146             "sizeBased-test2.log",
147      "witness/rolling/sbr-test2.log"));
148     assertTrue(Compare.compare(SizeBasedRollingTest.class,
149             "sizeBased-test2.0",
150      "witness/rolling/sbr-test2.0"));
151     assertTrue(Compare.compare(SizeBasedRollingTest.class,
152             "sizeBased-test2.1",
153      "witness/rolling/sbr-test2.1"));
154   }
155 
156     /***
157      * Same as testBasic but also with GZ compression.
158      */
159   public void test3() throws Exception {
160      PatternLayout layout = new PatternLayout("%m\n");
161      RollingFileAppender rfa = new RollingFileAppender();
162      rfa.setAppend(false);
163      rfa.setLayout(layout);
164 
165      FixedWindowRollingPolicy  fwrp = new FixedWindowRollingPolicy();
166      SizeBasedTriggeringPolicy sbtp = new SizeBasedTriggeringPolicy();
167 
168      sbtp.setMaxFileSize(100);
169      fwrp.setMinIndex(0);
170      rfa.setFile("sbr-test3.log");
171      fwrp.setFileNamePattern("sbr-test3.%i.gz");
172      fwrp.activateOptions();
173      rfa.setRollingPolicy(fwrp);
174      rfa.setTriggeringPolicy(sbtp);
175      rfa.activateOptions();
176      root.addAppender(rfa);
177 
178      // Write exactly 10 bytes with each log
179      for (int i = 0; i < 25; i++) {
180        Thread.sleep(100);
181        if (i < 10) {
182          logger.debug("Hello---" + i);
183        } else if (i < 100) {
184          logger.debug("Hello--" + i);
185        }
186      }
187 
188     assertTrue(new File("sbr-test3.log").exists());
189     assertTrue(new File("sbr-test3.0.gz").exists());
190     assertTrue(new File("sbr-test3.1.gz").exists());
191 
192     assertTrue(Compare.compare(SizeBasedRollingTest.class,
193             "sbr-test3.log",  "witness/rolling/sbr-test3.log"));
194     assertTrue(Compare.gzCompare(SizeBasedRollingTest.class,
195             "sbr-test3.0.gz", "witness/rolling/sbr-test3.0.gz"));
196     assertTrue(Compare.gzCompare(SizeBasedRollingTest.class,
197             "sbr-test3.1.gz", "witness/rolling/sbr-test3.1.gz"));
198   }
199 
200     /***
201      * Test basic rolling functionality with bogus path in file name pattern.
202      */
203   public void test4() throws Exception {
204     PatternLayout layout = new PatternLayout("%m\n");
205     RollingFileAppender rfa = new RollingFileAppender();
206     rfa.setName("ROLLING");
207     rfa.setAppend(false);
208     rfa.setLayout(layout);
209     rfa.setFile("sizeBased-test4.log");
210 
211     FixedWindowRollingPolicy swrp = new FixedWindowRollingPolicy();
212     SizeBasedTriggeringPolicy sbtp = new SizeBasedTriggeringPolicy();
213 
214     sbtp.setMaxFileSize(100);
215     swrp.setMinIndex(0);
216 
217     //
218     //   test4 directory should not exists.  Should cause all rollover attempts to fail.
219     //
220     swrp.setFileNamePattern("test4/sizeBased-test4.%i");
221     swrp.activateOptions();
222 
223     rfa.setRollingPolicy(swrp);
224     rfa.setTriggeringPolicy(sbtp);
225     rfa.activateOptions();
226     root.addAppender(rfa);
227 
228     // Write exactly 10 bytes with each log
229     for (int i = 0; i < 25; i++) {
230       if (i < 10) {
231         logger.debug("Hello---" + i);
232       } else if (i < 100) {
233         logger.debug("Hello--" + i);
234       }
235     }
236 
237     assertTrue(new File("sizeBased-test4.log").exists());
238 
239     assertTrue(Compare.compare(SizeBasedRollingTest.class,
240             "sizeBased-test4.log",
241      "witness/rolling/sbr-test4.log"));
242   }
243 
244     /***
245      * Checking handling of rename failures due to other access
246      * to the indexed files.
247      */
248   public void test5() throws Exception {
249     //
250 	//   delete any stray files that might confuse test
251     new File("sizeBased-test5.2").delete();
252     new File("sizeBased-test5.3").delete();
253     PatternLayout layout = new PatternLayout("%m\n");
254     RollingFileAppender rfa = new RollingFileAppender();
255     rfa.setName("ROLLING");
256     rfa.setAppend(false);
257     rfa.setLayout(layout);
258     rfa.setFile("sizeBased-test5.log");
259 
260     FixedWindowRollingPolicy swrp = new FixedWindowRollingPolicy();
261     SizeBasedTriggeringPolicy sbtp = new SizeBasedTriggeringPolicy();
262 
263     sbtp.setMaxFileSize(100);
264     swrp.setMinIndex(0);
265 
266     swrp.setFileNamePattern("sizeBased-test5.%i");
267     swrp.activateOptions();
268 
269     rfa.setRollingPolicy(swrp);
270     rfa.setTriggeringPolicy(sbtp);
271     rfa.activateOptions();
272     root.addAppender(rfa);
273 
274     //
275     //   put stray file above locked file
276     FileOutputStream os1 = new FileOutputStream("sizeBased-test5.1");
277     os1.close();
278 
279 
280     FileOutputStream os0 = new FileOutputStream("sizeBased-test5.0");
281 
282     // Write exactly 10 bytes with each log
283     for (int i = 0; i < 25; i++) {
284       if (i < 10) {
285         logger.debug("Hello---" + i);
286       } else if (i < 100) {
287         logger.debug("Hello--" + i);
288       }
289     }
290 
291     os0.close();
292 
293     if (new File("sizeBased-test5.3").exists()) {
294         //
295         //    looks like platform where open files can be renamed
296         //
297         assertTrue(new File("sizeBased-test5.log").exists());
298         assertTrue(new File("sizeBased-test5.0").exists());
299         assertTrue(new File("sizeBased-test5.1").exists());
300         assertTrue(new File("sizeBased-test5.2").exists());
301         assertTrue(new File("sizeBased-test5.3").exists());
302 
303         assertTrue(Compare.compare(
304                 SizeBasedRollingTest.class,
305                 "sizeBased-test5.log",
306          "witness/rolling/sbr-test2.log"));
307         assertTrue(Compare.compare(SizeBasedRollingTest.class,
308                 "sizeBased-test5.0",
309          "witness/rolling/sbr-test2.0"));
310         assertTrue(Compare.compare(SizeBasedRollingTest.class,
311                 "sizeBased-test5.1",
312          "witness/rolling/sbr-test2.1"));
313 
314     } else {
315         //
316         //  rollover attempts should all fail
317         //    so initial log file should have all log content
318         //    open file should be unaffected
319         //    stray file should have only been moved one slot.
320         assertTrue(new File("sizeBased-test5.log").exists());
321         assertTrue(new File("sizeBased-test5.0").exists());
322         assertTrue(new File("sizeBased-test5.2").exists());
323 
324         assertTrue(Compare.compare(
325                 SizeBasedRollingTest.class,"sizeBased-test5.log",
326             "witness/rolling/sbr-test4.log"));
327     }
328   }
329 
330 
331     /***
332      * Test basic rolling functionality with explicit setting of
333      * obsolete FixedWindowRollingPolicy.activeFileName.
334      * @deprecated Tests deprecated method
335      */
336   public void test6() throws Exception {
337     PatternLayout layout = new PatternLayout("%m\n");
338     RollingFileAppender rfa = new RollingFileAppender();
339     rfa.setName("ROLLING");
340     rfa.setAppend(false);
341     rfa.setLayout(layout);
342 
343     FixedWindowRollingPolicy swrp = new FixedWindowRollingPolicy();
344     SizeBasedTriggeringPolicy sbtp = new SizeBasedTriggeringPolicy();
345 
346     sbtp.setMaxFileSize(100);
347     swrp.setMinIndex(0);
348     swrp.setActiveFileName("sizeBased-test6.log");
349 
350     swrp.setFileNamePattern("sizeBased-test6.%i");
351     swrp.activateOptions();
352 
353     rfa.setRollingPolicy(swrp);
354     rfa.setTriggeringPolicy(sbtp);
355     rfa.activateOptions();
356     root.addAppender(rfa);
357 
358     // Write exactly 10 bytes with each log
359     for (int i = 0; i < 25; i++) {
360       if (i < 10) {
361         logger.debug("Hello---" + i);
362       } else if (i < 100) {
363         logger.debug("Hello--" + i);
364       }
365     }
366 
367     assertTrue(new File("sizeBased-test6.log").exists());
368     assertTrue(new File("sizeBased-test6.0").exists());
369     assertTrue(new File("sizeBased-test6.1").exists());
370 
371     assertTrue(Compare.compare(SizeBasedRollingTest.class,
372             "sizeBased-test6.log",
373      "witness/rolling/sbr-test2.log"));
374     assertTrue(Compare.compare(SizeBasedRollingTest.class,
375             "sizeBased-test6.0",
376      "witness/rolling/sbr-test2.0"));
377     assertTrue(Compare.compare(SizeBasedRollingTest.class,
378             "sizeBased-test6.1",
379      "witness/rolling/sbr-test2.1"));
380   }
381 
382 
383 }