Re: Raku IO IceDrive bug

On 10/21/23 20:50, Ralph Mellor wrote:
> Hi again. :)
> 
> Let me try again. I'll try cover things more clearly.
> 
> ----
> 
> #1 There was/is a bug in your code, or at least code that you
> say isn't working on your system. (It works on glot.io. See #3)
> 
> ```
> $WanIpFileName.IO.open(:w);
> spurt "$WanIpFileName", "New File Opened";
> ```
> 
> These two lines clash badly. They are a bug waiting to
> happen. The glot.io system resolves the clash in your
> favor, so the clash isn't apparent. You are saying that
> on your Windows system, the code fails.
> 
> The simplest thing to do is just fix the bug, rather than
> worry about understanding it. The simplest way to fix
> the bug is to simply drop the first line. It's redundant at
> best, and causes the bug at worst, so just get rid of it.
> 
> If you don't want to understand the bug, but do want to
> know about the other issues, skip ahead to #2 or #3.
> 
> ----
> 
> In case you *do* want to understand the bug, let's
> start with another way to fix the bug. You could write:
> ```
> my $handle = $WanIpFileName.IO.open(:w);
> $handle.spurt: "$WanIpFileName", "New File Opened";
> ```
> That works, and should work on Windows.
> 
> This time the code *saves the file handle* corresponding
> to the first line, and then uses that handle as the invocant
> of a `.spurt` *method*, thus connecting the handle opened
> in the first line to the `spurt` done in the second line.
> 
> Maybe *that* has explained all you need to know. If so,
> feel free to skip ahead to #2 or #3.
> 
> Repeating the two lines that clashed:
> ```
> $WanIpFileName.IO.open(:w);
> spurt "$WanIpFileName", "New File Opened";
> ```
> 
> The first line opens the file in write mode -- and then
> leaves it like that and throws away the file handle.
> 
> That's an issue. If you understand why it's an issue,
> then great. If you don't, then that's OK too, and I'll
> move on, because it isn't too important.
> 
> The second line has no idea the first line opened the
> very same file it's just about to open, so it tries to open
> it *again*, write to the file handle, and then close it.
> 
> Finally, at program exit, the file system tries to clean
> up an exiting process, eg closing any file handles left
> open and resolving clashes like your code generates.
> 
> On some systems the code will succeed. On your system
> you say it doesn't. See #3 for demo and further discussion.
> 
> ----
> 
> #2 There was/is a doc failure. I now see another one or two.
> 
> The doc failed to say that `spurt` opens the file. It should.
> 
> (Then you would presumably have understood you did not
> need the `open` line.)
> 
> The doc failed to say `open` returns a file handle. It should.
> 
> (Then you would presumably have understood that if you
> used an `open` line, you needed to keep the file handle
> and use a `.spurt` *method* on that file handle.)
> 
> The example doc you looked at includes a line that does
> the equivalent of `touch`. You thought you could use it
> but chop off the `.close`.
> 
> (But you didn't realize you needed to keep the file handle,
> as just explained.)
> 
> ----
> 
> #3 There is a Windows difference. Your code runs fine on glot.io.
> 
> Please click this link, and then the Run button:
> 
> https://glot.io/snippets/gpv7tdaca0
> 
> That contains your code. And it's working. The difference is it's not Windows.
> 
> NB. Each time you click Run, glot.io automatically cleans the
> file system. Every time. That's why it always says 'file does
> not exist' at the start. Every time.
> 
> NB. I added the lines declaring the missing variable and sub,
> and checking the file does not exist at the start, and some
> commented out stuff and so on. Feel free to edit the code to
> whatever you want if you want to. If you want to start over,
> click refresh on your browser and click 'Reload'.
> 
> ----
> love, raiph



Hi Raiph,

Thank you for all the time you spent on this!  It
is extremely appreciated.



I wrote a little test code:

WinCreateFileTest.pl6
~~~~~~~~~~~~~~~
#!/usr/bin/env raku

sub DirectoryExists( Str $DirPath     --> Bool ) { return 
"$DirPath".IO.d.Bool; }      # $Full DirPath format is `H:\MyDocsBackup`
sub DriveExists(     Str $DriveLetter --> Bool ) { return 
"$DriveLetter".IO.e.Bool; }  # $Drive Letter format is `A:\`
sub Exists(          Str $Path        --> Bool ) { return 
"$Path".IO.e.Bool; }         # file, dirctory, drive
sub FileExists(      Str $FilePath    --> Bool ) { return 
"$FilePath".IO.f.Bool; }     # $File Path format is `H:\IAmBackup`


my Str $TestFile = "WinEraseme.txt";

if FileExists( $TestFile )  {
    print "Previous $TestFile found.\n";
    spurt "$TestFile", "Old File Found\n";

} else {
    $TestFile.IO.open(:w).close;
    spurt "$TestFile", "New File Opened\n";
}

print Q[Now run `type ] ~ $TestFile ~ Q[`] ~ " to check your results\n"
~~~~~~~~~~~~~~~~~~


 >del WinEraseme.txt

 >raku WinCreateFileTest.pl6
Now run `type WinEraseme.txt` to check your results

 >type WinEraseme.txt
New File Opened


 >raku WinCreateFileTest.pl6
Previous WinEraseme.txt found.
Now run `type WinEraseme.txt` to check your results

 >type WinEraseme.txt
Old File Found

~~~~~~~~~~~~~~~~~~~

So clearly, Windows Raku can not use spurt if a
previous file handle to the file is open/dangling.

~~~~~~~~~~~~~~~~~~~

So three things need to be fixed:

1)  I need to add `.close` to my code when all I want to
do is to create a file so that Raku (`spurt`, etc.) won't
get a dangling file handle.

2)  A discussion in the documentation need to be added
on how to create a file and how to handle dangling file
handles (add `.close`).

      $NewFileName.IO.open(:w).close;

3)  Raku needs to error out when a dangling file handle
causes the Windows file API to return an error

~~~~~~~~~~~~~~~~~~~~~~

My IO Keeper for create a file:


Create new file:
     Create a new file.  Note: overwrites an old file (not verified):
         "yourfilename".IO.open(:w).close

     Note: if you do not add the `.close` you will have a
           dangling file handle which will interfere with `spurt`.
           There are instances where you would want this handle though

~~~~~~~~~~~~~~~~~~~~~~

Love (maybe, perhaps, I ain't saying),
-T