www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Windows to Linux Porting - timeCreated and timeLastAccessed

reply Vino <vino.bheeman hotmail.com> writes:
Hi All,

   Request your help, I have a D program written on Windows 
platform and the program is working as expected, now i am trying 
to port the same program to Linux, my program use the function 
"timeCreated" from std.file for Windows hugely where as in Linux 
we do not have the same function hence planned to use the 
function "timeLastAccessed" from std.file, so what is the best 
approach to port the program. I tried the below code but not 
working, so can you one please guide me on the right method to 
port the program to linux, below is the example code.

Example Code:
import std.stdio: writeln;
import std.container.array;
import std.file: dirEntries,isFile, SpanMode;
import std.algorithm: filter, map;
import std.typecons: Tuple, tuple;
import std.datetime.systime: SysTime;


version (Windows) { alias sTimeStamp = timeCreated; } else 
version (linux) { alias sTimeStamp = timeLastAccessed; }

auto clogClean (string LogDir ) {
Array!(Tuple!(string, SysTime)) dFiles;
  dFiles.insert(dirEntries(LogDir, SpanMode.shallow).filter!(a => 
a.isFile).map!(a => tuple(a.name, a.sTimeStamp)));
  return dFiles;
}

void main () {
string LogDir;
LogDir = "//DScript/Test";       //  Error: undefined identifier 
timeLastAccessed on Linux
LogDir = "C:\\DScript\\Others";  //  Error: undefined identifier 
timeCreated on Windows.
writeln(clogClean(LogDir));
}

From,
Vino.B
May 04 2018
next sibling parent reply Adam D. Ruppe <destructionator gmail.com> writes:
What are you actually trying to do with it? These functions are 
probably the wholly wrong approach.
May 04 2018
parent reply Vino <vino.bheeman hotmail.com> writes:
On Friday, 4 May 2018 at 12:38:07 UTC, Adam D. Ruppe wrote:

 What are you actually trying to do with it? These functions are 
 probably the wholly wrong approach.


Hi Adam,

  The existing program in Windows do few task's eg: Delete files 
older that certain days, and now we are trying to port to Linux, 
and above was just a example, hence asked the right approach for 
porting.



From,
Vino.B
May 04 2018
next sibling parent reply Jonathan M Davis <newsgroup.d jmdavisprog.com> writes:
On Friday, May 04, 2018 13:17:36 Vino via Digitalmars-d-learn wrote:

 On Friday, 4 May 2018 at 12:38:07 UTC, Adam D. Ruppe wrote:

 What are you actually trying to do with it? These functions are
 probably the wholly wrong approach.


 Hi Adam,

   The existing program in Windows do few task's eg: Delete files
 older that certain days, and now we are trying to port to Linux,
 and above was just a example, hence asked the right approach for
 porting.


Linux does not keep track of the creation time of a file. So, it will not
work to have a program on Linux ask a file how long it's been since the file
was created. If you want that information, you'll have to store it elsewhere
somehow (and that generally only works if you created the file in the first
place).

The modification time of the file is the time that the file was last changed
(which would be the creation time if it were only ever written to once, but
in the general case, it has no relation to the creation time at all). So,
you could use std.file.timeLastModified to find out if a file has been
changed within the last x number of days, but there is no way to find out
the creation time of a file by asking the filesystem.

- Jonathan M Davis
May 04 2018
parent reply Vino <vino.bheeman hotmail.com> writes:
On Friday, 4 May 2018 at 14:02:24 UTC, Jonathan M Davis wrote:

 On Friday, May 04, 2018 13:17:36 Vino via Digitalmars-d-learn 
 wrote:

 On Friday, 4 May 2018 at 12:38:07 UTC, Adam D. Ruppe wrote:

 What are you actually trying to do with it? These functions 
 are probably the wholly wrong approach.


 Hi Adam,

   The existing program in Windows do few task's eg: Delete 
 files
 older that certain days, and now we are trying to port to 
 Linux,
 and above was just a example, hence asked the right approach 
 for
 porting.


 Linux does not keep track of the creation time of a file. So, 
 it will not work to have a program on Linux ask a file how long 
 it's been since the file was created. If you want that 
 information, you'll have to store it elsewhere somehow (and 
 that generally only works if you created the file in the first 
 place).

 The modification time of the file is the time that the file was 
 last changed (which would be the creation time if it were only 
 ever written to once, but in the general case, it has no 
 relation to the creation time at all). So, you could use 
 std.file.timeLastModified to find out if a file has been 
 changed within the last x number of days, but there is no way 
 to find out the creation time of a file by asking the 
 filesystem.

 - Jonathan M Davis


Hi Jonathan,

   Thank you,  i got your point from the other forum topic which 
was raised by me earlier, hence decided to use modification time, 
the request is on how and the best approach to port the code from 
windows to Linux eg program below

Example Code:
import std.stdio: writeln;
import std.container.array;
import std.file: dirEntries,isFile, SpanMode;
import std.algorithm: filter, map;
import std.typecons: Tuple, tuple;
import std.datetime.systime: SysTime;


version (Windows) { alias sTimeStamp = timeCreated; } else 
version (linux) { alias sTimeStamp = timeLastAccessed; }

auto clogClean (string LogDir ) {
Array!(Tuple!(string, SysTime)) dFiles;
  dFiles.insert(dirEntries(LogDir, SpanMode.shallow).filter!(a => 
a.isFile).map!(a => tuple(a.name, a.sTimeStamp)));
  return dFiles;
}

void main () {
string LogDir;
LogDir = "//DScript/Test";       //  Error: undefined identifier 
timeLastAccessed on Linux
LogDir = "C:\\DScript\\Others";  //  Error: undefined identifier 
timeCreated on Windows.
writeln(clogClean(LogDir));
}

From,
Vino.B
May 04 2018
next sibling parent reply wjoe <none example.com> writes:
On Friday, 4 May 2018 at 14:24:36 UTC, Vino wrote:

 On Friday, 4 May 2018 at 14:02:24 UTC, Jonathan M Davis wrote:

 On Friday, May 04, 2018 13:17:36 Vino via Digitalmars-d-learn 
 wrote:

 On Friday, 4 May 2018 at 12:38:07 UTC, Adam D. Ruppe wrote:

 What are you actually trying to do with it? These functions 
 are probably the wholly wrong approach.


 Hi Adam,

   The existing program in Windows do few task's eg: Delete 
 files
 older that certain days, and now we are trying to port to 
 Linux,
 and above was just a example, hence asked the right approach 
 for
 porting.


 Linux does not keep track of the creation time of a file. So, 
 it will not work to have a program on Linux ask a file how 
 long it's been since the file was created. If you want that 
 information, you'll have to store it elsewhere somehow (and 
 that generally only works if you created the file in the first 
 place).

 The modification time of the file is the time that the file 
 was last changed (which would be the creation time if it were 
 only ever written to once, but in the general case, it has no 
 relation to the creation time at all). So, you could use 
 std.file.timeLastModified to find out if a file has been 
 changed within the last x number of days, but there is no way 
 to find out the creation time of a file by asking the 
 filesystem.

 - Jonathan M Davis


 Hi Jonathan,

   Thank you,  i got your point from the other forum topic which 
 was raised by me earlier, hence decided to use modification 
 time, the request is on how and the best approach to port the 
 code from windows to Linux eg program below

 Example Code:
 import std.stdio: writeln;
 import std.container.array;
 import std.file: dirEntries,isFile, SpanMode;
 import std.algorithm: filter, map;
 import std.typecons: Tuple, tuple;
 import std.datetime.systime: SysTime;


 version (Windows) { alias sTimeStamp = timeCreated; } else 
 version (linux) { alias sTimeStamp = timeLastAccessed; }

 auto clogClean (string LogDir ) {
 Array!(Tuple!(string, SysTime)) dFiles;
  dFiles.insert(dirEntries(LogDir, SpanMode.shallow).filter!(a 
 => a.isFile).map!(a => tuple(a.name, a.sTimeStamp)));
  return dFiles;
 }

 void main () {
 string LogDir;
 LogDir = "//DScript/Test";       //  Error: undefined 
 identifier timeLastAccessed on Linux
 LogDir = "C:\\DScript\\Others";  //  Error: undefined 
 identifier timeCreated on Windows.
 writeln(clogClean(LogDir));
 }

 From,
 Vino.B


Unlike NTFS for Windows there's a plethora of different file 
systems available to use for Linux, one of which doesn't even 
support deletion of files. You also have to keep in mind that 
even if the same file system is used, there is no guarantee that 
you have the same set of metadata available for a mount point 
each and every time.
Consider a file system that's mounted with the 'noatime' option, 
for instance, which doesn't log access times.

As far as I understand you are globing files, check times and 
then act upon that.
If I were to port this to Linux, or any other OS for that matter, 
I wouldn't depend on a feature of an OS.
Instead, since you have to look at a file either way to get the 
meta data (which you query with the stat family of functions), I 
would build my own database or cache with that information.
Glob the directory and add files not yet present with the current 
date (and any other meta data you might need).
Then query all the files of interest and do whatever you want to 
do with them and remove the entry.

Downside is you have possibly another dependency. On the plus 
side you could easily query all files older than X days or 
whatever with a single select and batch process them.
May 04 2018
parent reply Vino <vino.bheeman hotmail.com> writes:
On Friday, 4 May 2018 at 15:16:23 UTC, wjoe wrote:

 On Friday, 4 May 2018 at 14:24:36 UTC, Vino wrote:

 On Friday, 4 May 2018 at 14:02:24 UTC, Jonathan M Davis wrote:

 On Friday, May 04, 2018 13:17:36 Vino via Digitalmars-d-learn 
 wrote:

 [...]


 Linux does not keep track of the creation time of a file. So, 
 it will not work to have a program on Linux ask a file how 
 long it's been since the file was created. If you want that 
 information, you'll have to store it elsewhere somehow (and 
 that generally only works if you created the file in the 
 first place).

 The modification time of the file is the time that the file 
 was last changed (which would be the creation time if it were 
 only ever written to once, but in the general case, it has no 
 relation to the creation time at all). So, you could use 
 std.file.timeLastModified to find out if a file has been 
 changed within the last x number of days, but there is no way 
 to find out the creation time of a file by asking the 
 filesystem.

 - Jonathan M Davis


 Hi Jonathan,

   Thank you,  i got your point from the other forum topic 
 which was raised by me earlier, hence decided to use 
 modification time, the request is on how and the best approach 
 to port the code from windows to Linux eg program below

 Example Code:
 import std.stdio: writeln;
 import std.container.array;
 import std.file: dirEntries,isFile, SpanMode;
 import std.algorithm: filter, map;
 import std.typecons: Tuple, tuple;
 import std.datetime.systime: SysTime;


 version (Windows) { alias sTimeStamp = timeCreated; } else 
 version (linux) { alias sTimeStamp = timeLastAccessed; }

 auto clogClean (string LogDir ) {
 Array!(Tuple!(string, SysTime)) dFiles;
  dFiles.insert(dirEntries(LogDir, SpanMode.shallow).filter!(a 
 => a.isFile).map!(a => tuple(a.name, a.sTimeStamp)));
  return dFiles;
 }

 void main () {
 string LogDir;
 LogDir = "//DScript/Test";       //  Error: undefined 
 identifier timeLastAccessed on Linux
 LogDir = "C:\\DScript\\Others";  //  Error: undefined 
 identifier timeCreated on Windows.
 writeln(clogClean(LogDir));
 }

 From,
 Vino.B


 Unlike NTFS for Windows there's a plethora of different file 
 systems available to use for Linux, one of which doesn't even 
 support deletion of files. You also have to keep in mind that 
 even if the same file system is used, there is no guarantee 
 that you have the same set of metadata available for a mount 
 point each and every time.
 Consider a file system that's mounted with the 'noatime' 
 option, for instance, which doesn't log access times.

 As far as I understand you are globing files, check times and 
 then act upon that.
 If I were to port this to Linux, or any other OS for that 
 matter, I wouldn't depend on a feature of an OS.
 Instead, since you have to look at a file either way to get the 
 meta data (which you query with the stat family of functions), 
 I would build my own database or cache with that information.
 Glob the directory and add files not yet present with the 
 current date (and any other meta data you might need).
 Then query all the files of interest and do whatever you want 
 to do with them and remove the entry.

 Downside is you have possibly another dependency. On the plus 
 side you could easily query all files older than X days or 
 whatever with a single select and batch process them.


Hi Wjoe,

   Thank you very much, but what i am expecting is something like 
OS switch, based of OS type switch the funciton eg:

If OS is windows use the funciton timeCreated else if the OS is 
linux use the function timeLastAccessed in the below example 
program, something similar as stated in the link

https://dlang.org/spec/declaration.html#alias

Eg1:
version (Win32)
{
     alias myfoo = win32.foo;
}
version (linux)
{
     alias myfoo = linux.bar;
}



auto clogClean (string LogDir ) {
Array!(Tuple!(string, SysTime)) dFiles;


version (Windows) {  alias sTimeStamp = 
std.file.DirEntry.timeCreated;} else version (linux) { alias 
sTimeStamp = std.file.DirEntry.timeLastAccessed; }


dFiles.insert(dirEntries(LogDir, SpanMode.shallow).filter!(a => 
a.isFile).map!(a => tuple(a.name, a.sTimeStamp)));
  return dFiles;
}

From,
Vino.B
May 04 2018
parent reply wjoe <none example.com> writes:
On Friday, 4 May 2018 at 15:30:26 UTC, Vino wrote:

 On Friday, 4 May 2018 at 15:16:23 UTC, wjoe wrote:

 [...]


 Hi Wjoe,

   Thank you very much, but what i am expecting is something 
 like OS switch, based of OS type switch the funciton eg:

 If OS is windows use the funciton timeCreated else if the OS is 
 linux use the function timeLastAccessed in the below example 
 program, something similar as stated in the link

 https://dlang.org/spec/declaration.html#alias

 Eg1:
 version (Win32)
 {
     alias myfoo = win32.foo;
 }
 version (linux)
 {
     alias myfoo = linux.bar;
 }



 auto clogClean (string LogDir ) {
 Array!(Tuple!(string, SysTime)) dFiles;


 version (Windows) {  alias sTimeStamp = 
 std.file.DirEntry.timeCreated;} else version (linux) { alias 
 sTimeStamp = std.file.DirEntry.timeLastAccessed; }


 dFiles.insert(dirEntries(LogDir, SpanMode.shallow).filter!(a => 
 a.isFile).map!(a => tuple(a.name, a.sTimeStamp)));
  return dFiles;
 }

 From,
 Vino.B


I think that's not possible. You can't query information that 
hasn't been stored.

Your best bet in a Change-Function-Name-Port would probably be to 
use access time and mount the file system with options that won't 
touch that anymore after creation. But me thinks such a solution 
would be rather unreliable and not worth the time investment.
May 04 2018
parent wjoe <none example.com> writes:
On Friday, 4 May 2018 at 15:42:56 UTC, wjoe wrote:

 I think that's not possible. You can't query information that 
 hasn't been stored.


I stand corrected.

As Russel Winder points out there are file systems that store 
this information and since Linux 4.11 you can query it via 
statx(2).
May 07 2018
prev sibling parent Kagamin <spam here.lot> writes:
If you just want to clean logs, then use modification time on all 
oses:

auto clogClean (string LogDir ) {
Array!(Tuple!(string, SysTime)) dFiles;
  dFiles.insert(dirEntries(LogDir, SpanMode.shallow).filter!(a => 
a.isFile).map!(a => tuple(a.name, a.timeLastModified)));
  return dFiles;
}
May 04 2018
prev sibling parent Russel Winder <russel winder.org.uk> writes:
On Fri, 2018-05-04 at 08:02 -0600, Jonathan M Davis via Digitalmars-d-learn
wrote:

=20


[=E2=80=A6]

 Linux does not keep track of the creation time of a file. So, it will not
 work to have a program on Linux ask a file how long it's been since the f=


ile

 was created. If you want that information, you'll have to store it elsewh=


ere
[=E2=80=A6]

Linux itself doesn't but most filesystems certainly do.  Ext4 definitely do=
es.


https://unix.stackexchange.com/questions/7562/what-file-systems-on-linux-st=
ore
-the-creation-time

--=20
Russel.
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
Dr Russel Winder      t: +44 20 7585 2200
41 Buckmaster Road    m: +44 7770 465 077
London SW11 1EN, UK   w: www.russel.org.uk
May 05 2018
prev sibling parent reply Jesse Phillips <Jesse.K.Phillips+D gmail.com> writes:
On Friday, 4 May 2018 at 11:49:24 UTC, Vino wrote:

 Hi All,

   Request your help, I have a D program written on Windows 
 platform and the program is working as expected, now i am 
 trying to port the same program to Linux, my program use the 
 function "timeCreated" from std.file for Windows hugely where 
 as in Linux we do not have the same function hence planned to 
 use the function "timeLastAccessed" from std.file, so what is 
 the best approach to port the program. I tried the below code 
 but not working, so can you one please guide me on the right 
 method to port the program to linux, below is the example code.


I wouldn't use time created. It can be newer than last modified 
this wholey inacurate. Last accessed could be a much more 
appopriate choice if trying to determine what is important.
May 07 2018
parent Jesse Phillips <Jesse.K.Phillips+D gmail.com> writes:
On Monday, 7 May 2018 at 14:31:23 UTC, Jesse Phillips wrote:

 I wouldn't use time created. It can be newer than last modified 
 this wholey inacurate. Last accessed could be a much more 
 appopriate choice if trying to determine what is important.


Sorry, to answer your actual question, I do believe that using 
the OS version specification to select the function is correct.
May 07 2018