SkidSec WebShell

Server Address : 172.31.38.4

Web Server : Apache/2.4.58 (Ubuntu)

Uname : Linux ip-172-31-38-4 6.14.0-1017-aws #17~24.04.1-Ubuntu SMP Wed Nov 5 10:48:17 UTC 2025 x86_64

PHP Version : 7.4.33

# Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. from __future__ import annotations import contextlib import errno import os import stat import time from unittest import skipIf from twisted.python import logfile, runtime from twisted.trial.unittest import TestCase class LogFileTests(TestCase): """ Test the rotating log file. """ def setUp(self) -> None: self.dir = self.mktemp() os.makedirs(self.dir) self.name = "test.log" self.path = os.path.join(self.dir, self.name) def tearDown(self) -> None: """ Restore back write rights on created paths: if tests modified the rights, that will allow the paths to be removed easily afterwards. """ os.chmod(self.dir, 0o777) if os.path.exists(self.path): os.chmod(self.path, 0o777) def test_abstractShouldRotate(self) -> None: """ L{BaseLogFile.shouldRotate} is abstract and must be implemented by subclass. """ log = logfile.BaseLogFile(self.name, self.dir) self.addCleanup(log.close) self.assertRaises(NotImplementedError, log.shouldRotate) def test_writing(self) -> None: """ Log files can be written to, flushed and closed. Closing a log file also flushes it. """ with contextlib.closing(logfile.LogFile(self.name, self.dir)) as log: log.write("123") log.write("456") log.flush() log.write("7890") with open(self.path) as f: self.assertEqual(f.read(), "1234567890") def test_rotation(self) -> None: """ Rotating log files autorotate after a period of time, and can also be manually rotated. """ # this logfile should rotate every 10 bytes with contextlib.closing( logfile.LogFile(self.name, self.dir, rotateLength=10) ) as log: # test automatic rotation log.write("123") log.write("4567890") log.write("1" * 11) self.assertTrue(os.path.exists(f"{self.path}.1")) self.assertFalse(os.path.exists(f"{self.path}.2")) log.write("") self.assertTrue(os.path.exists(f"{self.path}.1")) self.assertTrue(os.path.exists(f"{self.path}.2")) self.assertFalse(os.path.exists(f"{self.path}.3")) log.write("3") self.assertFalse(os.path.exists(f"{self.path}.3")) # test manual rotation log.rotate() self.assertTrue(os.path.exists(f"{self.path}.3")) self.assertFalse(os.path.exists(f"{self.path}.4")) self.assertEqual(log.listLogs(), [1, 2, 3]) def test_append(self) -> None: """ Log files can be written to, closed. Their size is the number of bytes written to them. Everything that was written to them can be read, even if the writing happened on separate occasions, and even if the log file was closed in between. """ with contextlib.closing(logfile.LogFile(self.name, self.dir)) as log: log.write("0123456789") log = logfile.LogFile(self.name, self.dir) self.addCleanup(log.close) self.assertEqual(log.size, 10) self.assertEqual(log._file.tell(), log.size) log.write("abc") self.assertEqual(log.size, 13) self.assertEqual(log._file.tell(), log.size) f = log._file f.seek(0, 0) self.assertEqual(f.read(), b"0123456789abc") def test_logReader(self) -> None: """ Various tests for log readers. First of all, log readers can get logs by number and read what was written to those log files. Getting nonexistent log files raises C{ValueError}. Using anything other than an integer index raises C{TypeError}. As logs get older, their log numbers increase. """ log = logfile.LogFile(self.name, self.dir) self.addCleanup(log.close) log.write("abc\n") log.write("def\n") log.rotate() log.write("ghi\n") log.flush() # check reading logs self.assertEqual(log.listLogs(), [1]) with contextlib.closing(log.getCurrentLog()) as reader: reader._file.seek(0) self.assertEqual(reader.readLines(), ["ghi\n"]) self.assertEqual(reader.readLines(), []) with contextlib.closing(log.getLog(1)) as reader: self.assertEqual(reader.readLines(), ["abc\n", "def\n"]) self.assertEqual(reader.readLines(), []) # check getting illegal log readers self.assertRaises(ValueError, log.getLog, 2) self.assertRaises(TypeError, log.getLog, "1") # check that log numbers are higher for older logs log.rotate() self.assertEqual(log.listLogs(), [1, 2]) with contextlib.closing(log.getLog(1)) as reader: reader._file.seek(0) self.assertEqual(reader.readLines(), ["ghi\n"]) self.assertEqual(reader.readLines(), []) with contextlib.closing(log.getLog(2)) as reader: self.assertEqual(reader.readLines(), ["abc\n", "def\n"]) self.assertEqual(reader.readLines(), []) def test_LogReaderReadsZeroLine(self) -> None: """ L{LogReader.readLines} supports reading no line. """ # We don't need any content, just a file path that can be opened. with open(self.path, "w"): pass reader = logfile.LogReader(self.path) self.addCleanup(reader.close) self.assertEqual([], reader.readLines(0)) def test_modePreservation(self) -> None: """ Check rotated files have same permissions as original. """ open(self.path, "w").close() os.chmod(self.path, 0o707) mode = os.stat(self.path)[stat.ST_MODE] log = logfile.LogFile(self.name, self.dir) self.addCleanup(log.close) log.write("abc") log.rotate() self.assertEqual(mode, os.stat(self.path)[stat.ST_MODE]) def test_noPermission(self) -> None: """ Check it keeps working when permission on dir changes. """ log = logfile.LogFile(self.name, self.dir) self.addCleanup(log.close) log.write("abc") # change permissions so rotation would fail os.chmod(self.dir, 0o555) # if this succeeds, chmod doesn't restrict us, so we can't # do the test try: f = open(os.path.join(self.dir, "xxx"), "w") except OSError: pass else: f.close() return log.rotate() # this should not fail log.write("def") log.flush() f = log._file self.assertEqual(f.tell(), 6) f.seek(0, 0) self.assertEqual(f.read(), b"abcdef") def test_maxNumberOfLog(self) -> None: """ Test it respect the limit on the number of files when maxRotatedFiles is not None. """ log = logfile.LogFile(self.name, self.dir, rotateLength=10, maxRotatedFiles=3) self.addCleanup(log.close) log.write("1" * 11) log.write("2" * 11) self.assertTrue(os.path.exists(f"{self.path}.1")) log.write("3" * 11) self.assertTrue(os.path.exists(f"{self.path}.2")) log.write("4" * 11) self.assertTrue(os.path.exists(f"{self.path}.3")) with open(f"{self.path}.3") as fp: self.assertEqual(fp.read(), "1" * 11) log.write("5" * 11) with open(f"{self.path}.3") as fp: self.assertEqual(fp.read(), "2" * 11) self.assertFalse(os.path.exists(f"{self.path}.4")) def test_fromFullPath(self) -> None: """ Test the fromFullPath method. """ log1 = logfile.LogFile(self.name, self.dir, 10, defaultMode=0o777) self.addCleanup(log1.close) log2 = logfile.LogFile.fromFullPath(self.path, 10, defaultMode=0o777) self.addCleanup(log2.close) self.assertEqual(log1.name, log2.name) self.assertEqual(os.path.abspath(log1.path), log2.path) self.assertEqual(log1.rotateLength, log2.rotateLength) self.assertEqual(log1.defaultMode, log2.defaultMode) def test_defaultPermissions(self) -> None: """ Test the default permission of the log file: if the file exist, it should keep the permission. """ with open(self.path, "wb"): os.chmod(self.path, 0o707) currentMode = stat.S_IMODE(os.stat(self.path)[stat.ST_MODE]) log1 = logfile.LogFile(self.name, self.dir) self.assertEqual(stat.S_IMODE(os.stat(self.path)[stat.ST_MODE]), currentMode) self.addCleanup(log1.close) def test_specifiedPermissions(self) -> None: """ Test specifying the permissions used on the log file. """ log1 = logfile.LogFile(self.name, self.dir, defaultMode=0o066) self.addCleanup(log1.close) mode = stat.S_IMODE(os.stat(self.path)[stat.ST_MODE]) if runtime.platform.isWindows(): # The only thing we can get here is global read-only self.assertEqual(mode, 0o444) else: self.assertEqual(mode, 0o066) @skipIf(runtime.platform.isWindows(), "Can't test reopen on Windows") def test_reopen(self) -> None: """ L{logfile.LogFile.reopen} allows to rename the currently used file and make L{logfile.LogFile} create a new file. """ with contextlib.closing(logfile.LogFile(self.name, self.dir)) as log1: log1.write("hello1") savePath = os.path.join(self.dir, "save.log") os.rename(self.path, savePath) log1.reopen() log1.write("hello2") with open(self.path) as f: self.assertEqual(f.read(), "hello2") with open(savePath) as f: self.assertEqual(f.read(), "hello1") def test_nonExistentDir(self) -> None: """ Specifying an invalid directory to L{LogFile} raises C{IOError}. """ e = self.assertRaises( IOError, logfile.LogFile, self.name, "this_dir_does_not_exist" ) self.assertEqual(e.errno, errno.ENOENT) def test_cantChangeFileMode(self) -> None: """ Opening a L{LogFile} which can be read and write but whose mode can't be changed doesn't trigger an error. """ if runtime.platform.isWindows(): name, directory = "NUL", "" expectedPath = "NUL" else: name, directory = "null", "/dev" expectedPath = "/dev/null" log = logfile.LogFile(name, directory, defaultMode=0o555) self.addCleanup(log.close) self.assertEqual(log.path, expectedPath) self.assertEqual(log.defaultMode, 0o555) def test_listLogsWithBadlyNamedFiles(self) -> None: """ L{LogFile.listLogs} doesn't choke if it encounters a file with an unexpected name. """ log = logfile.LogFile(self.name, self.dir) self.addCleanup(log.close) with open(f"{log.path}.1", "w") as fp: fp.write("123") with open(f"{log.path}.bad-file", "w") as fp: fp.write("123") self.assertEqual([1], log.listLogs()) def test_listLogsIgnoresZeroSuffixedFiles(self) -> None: """ L{LogFile.listLogs} ignores log files which rotated suffix is 0. """ log = logfile.LogFile(self.name, self.dir) self.addCleanup(log.close) for i in range(0, 3): with open(f"{log.path}.{i}", "w") as fp: fp.write("123") self.assertEqual([1, 2], log.listLogs()) class RiggedDailyLogFile(logfile.DailyLogFile): _clock = 0.0 def _openFile(self) -> None: logfile.DailyLogFile._openFile(self) # rig the date to match _clock, not mtime self.lastDate = self.toDate() def toDate(self, *args: float) -> tuple[int, int, int]: if args: return time.gmtime(*args)[:3] return time.gmtime(self._clock)[:3] class DailyLogFileTests(TestCase): """ Test rotating log file. """ def setUp(self) -> None: self.dir = self.mktemp() os.makedirs(self.dir) self.name = "testdaily.log" self.path = os.path.join(self.dir, self.name) def test_writing(self) -> None: """ A daily log file can be written to like an ordinary log file. """ with contextlib.closing(RiggedDailyLogFile(self.name, self.dir)) as log: log.write("123") log.write("456") log.flush() log.write("7890") with open(self.path) as f: self.assertEqual(f.read(), "1234567890") def test_rotation(self) -> None: """ Daily log files rotate daily. """ log = RiggedDailyLogFile(self.name, self.dir) self.addCleanup(log.close) days = [(self.path + "." + log.suffix(day * 86400)) for day in range(3)] # test automatic rotation log._clock = 0.0 # 1970/01/01 00:00.00 log.write("123") log._clock = 43200 # 1970/01/01 12:00.00 log.write("4567890") log._clock = 86400 # 1970/01/02 00:00.00 log.write("1" * 11) self.assertTrue(os.path.exists(days[0])) self.assertFalse(os.path.exists(days[1])) log._clock = 172800 # 1970/01/03 00:00.00 log.write("") self.assertTrue(os.path.exists(days[0])) self.assertTrue(os.path.exists(days[1])) self.assertFalse(os.path.exists(days[2])) log._clock = 259199 # 1970/01/03 23:59.59 log.write("3") self.assertFalse(os.path.exists(days[2])) def test_getLog(self) -> None: """ Test retrieving log files with L{DailyLogFile.getLog}. """ data = ["1\n", "2\n", "3\n"] log = RiggedDailyLogFile(self.name, self.dir) self.addCleanup(log.close) for d in data: log.write(d) log.flush() # This returns the current log file. r = log.getLog(0.0) self.addCleanup(r.close) self.assertEqual(data, r.readLines()) # We can't get this log, it doesn't exist yet. self.assertRaises(ValueError, log.getLog, 86400) log._clock = 86401 # New day r.close() log.rotate() r = log.getLog(0) # We get the previous log self.addCleanup(r.close) self.assertEqual(data, r.readLines()) def test_rotateAlreadyExists(self) -> None: """ L{DailyLogFile.rotate} doesn't do anything if they new log file already exists on the disk. """ log = RiggedDailyLogFile(self.name, self.dir) self.addCleanup(log.close) # Build a new file with the same name as the file which would be created # if the log file is to be rotated. newFilePath = f"{log.path}.{log.suffix(log.lastDate)}" with open(newFilePath, "w") as fp: fp.write("123") previousFile = log._file log.rotate() self.assertEqual(previousFile, log._file) @skipIf( runtime.platform.isWindows(), "Making read-only directories on Windows is too complex for this " "test to reasonably do.", ) def test_rotatePermissionDirectoryNotOk(self) -> None: """ L{DailyLogFile.rotate} doesn't do anything if the directory containing the log files can't be written to. """ log = logfile.DailyLogFile(self.name, self.dir) self.addCleanup(log.close) os.chmod(log.directory, 0o444) # Restore permissions so tests can be cleaned up. self.addCleanup(os.chmod, log.directory, 0o755) previousFile = log._file log.rotate() self.assertEqual(previousFile, log._file) def test_rotatePermissionFileNotOk(self) -> None: """ L{DailyLogFile.rotate} doesn't do anything if the log file can't be written to. """ log = logfile.DailyLogFile(self.name, self.dir) self.addCleanup(log.close) os.chmod(log.path, 0o444) previousFile = log._file log.rotate() self.assertEqual(previousFile, log._file) def test_toDate(self) -> None: """ Test that L{DailyLogFile.toDate} converts its timestamp argument to a time tuple (year, month, day). """ log = logfile.DailyLogFile(self.name, self.dir) self.addCleanup(log.close) timestamp = time.mktime((2000, 1, 1, 0, 0, 0, 0, 0, 0)) self.assertEqual((2000, 1, 1), log.toDate(timestamp)) def test_toDateDefaultToday(self) -> None: """ Test that L{DailyLogFile.toDate} returns today's date by default. By mocking L{time.localtime}, we ensure that L{DailyLogFile.toDate} returns the first 3 values of L{time.localtime} which is the current date. Note that we don't compare the *real* result of L{DailyLogFile.toDate} to the *real* current date, as there's a slight possibility that the date changes between the 2 function calls. """ def mock_localtime(*args: object) -> list[int]: self.assertEqual((), args) return list(range(0, 9)) log = logfile.DailyLogFile(self.name, self.dir) self.addCleanup(log.close) self.patch(time, "localtime", mock_localtime) logDate = log.toDate() self.assertEqual([0, 1, 2], logDate) def test_toDateUsesArgumentsToMakeADate(self) -> None: """ Test that L{DailyLogFile.toDate} uses its arguments to create a new date. """ log = logfile.DailyLogFile(self.name, self.dir) self.addCleanup(log.close) date = (2014, 10, 22) seconds = time.mktime(date + (0,) * 6) logDate = log.toDate(seconds) self.assertEqual(date, logDate)