~upstart-devel/upstart/trunk

« back to all changes in this revision

Viewing changes to init/tests/test_log.c

mergeĀ lp:~vorlon/upstart/upstart-fix-racy-tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
34
34
#include "job.h"
35
35
#include "test_util_common.h"
36
36
 
 
37
extern int log_flushed;
 
38
 
37
39
/*
38
40
 * To help with understanding the TEST_ALLOC_FAIL peculiarities
39
41
 * below...
652
654
        TEST_FREE (log);
653
655
 
654
656
        /************************************************************/
 
657
        TEST_FEATURE ("ensure logger unflushed list ignores already flushed data");
 
658
 
 
659
        /* Reset */
 
660
        log_flushed = 0;
 
661
 
 
662
        TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
663
 
 
664
        TEST_GT (sprintf (filename, "%s/test.log", dirname), 0);
 
665
 
 
666
        TEST_NE (log_unflushed_files, NULL);
 
667
        TEST_TRUE (NIH_LIST_EMPTY (log_unflushed_files));
 
668
 
 
669
        TEST_EQ (stat (dirname, &statbuf), 0);
 
670
 
 
671
        /* Save */
 
672
        old_perms = statbuf.st_mode;
 
673
 
 
674
        /* Make file inaccessible */
 
675
        TEST_EQ (chmod (dirname, 0x0), 0);
 
676
 
 
677
        log = log_new (NULL, filename, pty_master, 0);
 
678
        TEST_NE_P (log, NULL);
 
679
 
 
680
        /* Write data to simulate a job process, but _DON'T_ close the
 
681
         * fd (to simulate the job spawning another process which olds
 
682
         * the fd open).
 
683
         */
 
684
        ret = write (pty_slave, str, strlen (str));
 
685
        TEST_GT (ret, 0);
 
686
        ret = write (pty_slave, "\n", 1);
 
687
        TEST_EQ (ret, 1);
 
688
 
 
689
        assert0 (log->unflushed->len);
 
690
        TEST_EQ_P (log->unflushed->buf, NULL);
 
691
 
 
692
        TEST_NE_P (log->io, NULL);
 
693
 
 
694
        TEST_WATCH_UPDATE ();
 
695
 
 
696
        /* nih_io_closed() should not have been called */
 
697
        TEST_NE_P (log->io, NULL);
 
698
 
 
699
        TEST_EQ_STR (log->unflushed->buf, "hello, world!\r\n");
 
700
 
 
701
        /* +2 for '\r\n' */
 
702
        TEST_EQ (log->unflushed->len, 2 + strlen (str));
 
703
 
 
704
        /* Ensure no log file written */
 
705
        TEST_LT (stat (filename, &statbuf), 0);
 
706
 
 
707
        TEST_TRUE (NIH_LIST_EMPTY (log_unflushed_files));
 
708
 
 
709
        TEST_FREE_TAG (log);
 
710
 
 
711
        /* Force the usual code path for early boot on a normal system
 
712
         * when a job produces output before the disks are writable.
 
713
         */
 
714
        log->open_errno = EROFS;
 
715
 
 
716
        TEST_EQ (log_handle_unflushed (NULL, log), 0);
 
717
 
 
718
        TEST_FALSE (NIH_LIST_EMPTY (log_unflushed_files));
 
719
 
 
720
        /* Restore access */
 
721
        TEST_EQ (chmod (dirname, old_perms), 0);
 
722
 
 
723
        TEST_NE_P (log->io, NULL);
 
724
 
 
725
        /* Simulate the data having already been flushed to disk
 
726
         * and nih_io_closed() having been called.
 
727
         */
 
728
        log->io = NULL;
 
729
        log->unflushed->len = 0;
 
730
        log->unflushed->buf = NULL;
 
731
        log->remote_closed = 1;
 
732
 
 
733
        ret = log_clear_unflushed ();
 
734
        TEST_EQ (ret, 0);
 
735
 
 
736
        TEST_FREE (log);
 
737
 
 
738
        /* Ensure no log file written */
 
739
        TEST_LT (stat (filename, &statbuf), 0);
 
740
 
 
741
        /* Tidy up */
 
742
        close (pty_slave);
 
743
        
 
744
        /************************************************************/
655
745
        TEST_FEATURE ("ensure logger flushes when destroyed with uid 0");
656
746
 
657
747
        TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
1130
1220
test_log_destroy (void)
1131
1221
{
1132
1222
        Log  *log;
 
1223
        Log  *tmp_log;
1133
1224
        int   ret;
1134
1225
        int   flags;
1135
1226
        char  str[] = "hello, world!";
1138
1229
        int   found_fd;
1139
1230
        char  filename[1024];
1140
1231
        int   fd;
 
1232
        NihListEntry *entry;
 
1233
        struct stat  statbuf;
 
1234
        char  *p;
1141
1235
 
1142
1236
        TEST_FUNCTION ("log_destroy");
1143
1237
 
1207
1301
        TEST_FREE (log->unflushed);
1208
1302
 
1209
1303
        /************************************************************/
 
1304
        TEST_FEATURE ("ensure unflushed data moved to unflushed list with uid 0");
 
1305
 
 
1306
        TEST_TRUE (NIH_LIST_EMPTY (log_unflushed_files));
 
1307
 
 
1308
        TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
 
1309
 
 
1310
        TEST_FILENAME (filename);
 
1311
 
 
1312
        /* Make file inaccessible to ensure data cannot be written
 
1313
         * and will thus be added to the unflushed buffer.
 
1314
         */
 
1315
        fd = open (filename, O_CREAT | O_EXCL, 0);
 
1316
        TEST_NE (fd, -1);
 
1317
        close (fd);
 
1318
 
 
1319
        p = nih_strdup (NULL, "hello");
 
1320
        TEST_NE_P (p, NULL);
 
1321
 
 
1322
        log = log_new (p, filename, pty_master, 0);
 
1323
        TEST_NE_P (log, NULL);
 
1324
 
 
1325
        TEST_ALLOC_PARENT (log, p);
 
1326
 
 
1327
        ret = write (pty_slave, str, strlen (str));
 
1328
        TEST_GT (ret, 0);
 
1329
 
 
1330
        TEST_WATCH_UPDATE ();
 
1331
        close (pty_slave);
 
1332
        TEST_NE_P (log->unflushed, NULL);
 
1333
        TEST_EQ (log->unflushed->len, strlen(str));
 
1334
        TEST_EQ_STR (log->unflushed->buf, str);
 
1335
        TEST_FREE_TAG (log);
 
1336
 
 
1337
        /* reset */
 
1338
        log_flushed = 0;
 
1339
 
 
1340
        TEST_TRUE (NIH_LIST_EMPTY (log_unflushed_files));
 
1341
        ret = log_handle_unflushed (p, log);
 
1342
        TEST_EQ (ret, 0);
 
1343
 
 
1344
        TEST_FALSE (NIH_LIST_EMPTY (log_unflushed_files));
 
1345
 
 
1346
        TEST_ALLOC_NOT_PARENT (log, p);
 
1347
 
 
1348
        entry = (NihListEntry *)log_unflushed_files->next;
 
1349
        TEST_NE_P (entry, NULL);
 
1350
        TEST_FREE_TAG (entry);
 
1351
        TEST_ALLOC_PARENT (entry, log_unflushed_files);
 
1352
 
 
1353
        /* Free the original parent object and ensure it doesn't free
 
1354
         * the log.
 
1355
         */
 
1356
        nih_free (p);
 
1357
 
 
1358
        TEST_FALSE (NIH_LIST_EMPTY (log_unflushed_files));
 
1359
        TEST_NOT_FREE (log);
 
1360
 
 
1361
        tmp_log = entry->data;
 
1362
        TEST_EQ_P (tmp_log, log);
 
1363
        TEST_ALLOC_PARENT (log, entry);
 
1364
 
 
1365
        /* make file accessible again */
 
1366
        assert0 (chmod (filename, 0755));
 
1367
 
 
1368
        ret = log_clear_unflushed ();
 
1369
        assert0 (ret);
 
1370
 
 
1371
        TEST_FREE (entry);
 
1372
        TEST_FREE (log);
 
1373
 
 
1374
        assert0 (stat (filename, &statbuf));
 
1375
        TEST_EQ (statbuf.st_size, strlen (str));
 
1376
 
 
1377
        TEST_TRUE (NIH_LIST_EMPTY (log_unflushed_files));
 
1378
 
 
1379
        /* full reset */
 
1380
        log_flushed = 0;
 
1381
        nih_free (log_unflushed_files);
 
1382
        log_unflushed_files = NULL;
 
1383
        log_unflushed_init ();
 
1384
 
 
1385
        nih_free (nih_io_watches);
 
1386
        nih_io_watches = NULL;
 
1387
        nih_io_init ();
 
1388
 
 
1389
        assert0 (unlink (filename));
 
1390
 
 
1391
        /************************************************************/
1210
1392
        TEST_FEATURE ("ensure watch freed when log destroyed");
1211
1393
 
 
1394
        /* Make file inaccessible to ensure data cannot be written
 
1395
         * and will thus be added to the unflushed buffer.
 
1396
         */
 
1397
        fd = open (filename, O_CREAT | O_EXCL, 0);
 
1398
        TEST_NE (fd, -1);
 
1399
        close (fd);
 
1400
 
1212
1401
        TEST_EQ (openpty (&pty_master, &pty_slave, NULL, NULL, NULL), 0);
1213
1402
 
1214
1403
        log = log_new (NULL, filename, pty_master, 0);