Recent changes to feature-requests

#4 Parameter for Update/UpdatePacked/UdateNoV2tag to decide if Backup required (default true)

Andrew Pearmund — Sat, 14 Feb 2015 20:37:30 -0000

status: open --> closed
assigned_to: Andrew Pearmund

#4 Parameter for Update/UpdatePacked/UdateNoV2tag to decide if Backup required (default true)

Andrew Pearmund — Sat, 14 Feb 2015 20:36:41 -0000

Sorry it's taken so long to look at this again. I've put this into svn now.
NonNtfsReplace got split into 2 separate functions for 'with' and 'without' a permanent backup; it looked clearer that way.

#4 Parameter for Update/UpdatePacked/UdateNoV2tag to decide if Backup required (default true)

ScruffR — Tue, 06 Jan 2015 15:24:21 -0000

After looking a bit closer, I'd suspect that my (new) way is not really "unsafe", since there actually are two files involved (the original and the new .$$$ file).

Once we reach the call to File.Move() we can already be certain that the .$$$ file was successfully created in our destination folder.

And having a look at the doc about File.Move() all expected exceptions should not harm the original file.
Only successful calls would do away with the original file - and even if the rename would not succeed we'd still have the .$$$ file.

#4 Parameter for Update/UpdatePacked/UdateNoV2tag to decide if Backup required (default true)

ScruffR — Tue, 06 Jan 2015 08:39:38 -0000

I'm not sure, which version you looked at, because I also found the null exception.
That was one of the reasons why I deleted the original posts and uploaded the files new.
But as for your the comment about the unsafe name swapping, I'd have to have another look. I only did a quick "fix" and haven't looked as close as I probably should have done ;-)

#4 Parameter for Update/UpdatePacked/UdateNoV2tag to decide if Backup required (default true)

Andrew Pearmund — Mon, 05 Jan 2015 23:56:44 -0000

Having looked at the code, I'm not sure what you're actually trying to achieve.

Are you trying to do the file name swapping in an unsafe manner, so it doesn't use a temp file at all while swapping a rewritten file over the old one? That's what it looks like the code is doing, There's still problems with a null backupLocation being supplied to the System.IO.File.Replace function, too.

I suspect what you're really trying to do is make sure there's no backup file left over once the rewrite has completed successfully. If so, it would be much better to let it use a temp backup file as normal, then use a parameter to arrange for it to be deleted when the operation has finished.

#4 Parameter for Update/UpdatePacked/UdateNoV2tag to decide if Backup required (default true)

ScruffR — Sun, 04 Jan 2015 20:36:21 -0000

And here the FileMover.cs

  public static class FileMover
  {
    /// <summary>
    /// Securely moves a file to a new location. Overwrites any
    /// preexisting file at new location (= replacing file).
    /// </summary>
    /// <remarks>
    /// If NTFS is available this is done via File.Replace.
    /// If NTFS is not available it will be moved via deleting
    /// any preexisting file and moving. Do NOT rely on the
    /// backupFile being there - or not - after the move process.
    /// That is not predetermined. This method is clearly
    /// optimized for the case that NTFS is available. Consider NOT
    /// using it on any other filesystem, if performance is an issue!
    /// </remarks>
    /// <param name="sourceLocation">The file to be moved.</param>
    /// <param name="targetLocation">The new resting place of the file.</param>
    /// <param name="backupLocation">A backup location that is used when replacing.</param>
    public static void FileMove(FileInfo sourceLocation,
                                 FileInfo targetLocation,
                                 FileInfo backupLocation)
    {
      if (targetLocation.Exists)
      {
        try
        {
          /////// if backupLocation is null no backup
          File.Replace(sourceLocation.FullName,
                       targetLocation.FullName,
                       backupLocation.FullName,
                       true);
        }
        catch (PlatformNotSupportedException)
        {
          // Not operating on an NTFS volume
          NonNtfsReplace(sourceLocation,
                         targetLocation,
                         backupLocation);
        }
      }
      else
      {
        File.Move(sourceLocation.FullName, targetLocation.FullName);
      }
    }

    private static void NonNtfsReplace(FileInfo sourceLocation,
                                       FileInfo targetLocation,
                                       FileInfo backupLocation)
    {
      // a unique name for a temp backup
      FileInfo backup2Location = null;

      /////////////////////////////////////////////////////
      if (backupLocation != null)
      {
      /////////////////////////////////////////////////////
        // make sure there's space for the backup
        if (backupLocation.Exists)
        {
          // find unique name for backup2
          string backup2Name = Path.Combine(Path.GetDirectoryName(backupLocation.FullName), Path.GetRandomFileName());
          backup2Location = new FileInfo(backup2Name);

          // rename the old backup to backup2
          // if this fails we just exit; no permanent changes have been made yet.
          File.Move(backupLocation.FullName, backup2Location.FullName);
        }

        try
        {
          // rename the old target to backup
          // if this fails we need to rename the old backup2 back
          File.Move(targetLocation.FullName, backupLocation.FullName);
        }
        catch
        {
          if (backup2Location != null)
          {
            // we've got a backup2 to unwind too
            // we managed to rename it once before, so this will probably work again
            File.Move(backup2Location.FullName, backupLocation.FullName);
          }
          throw;
        }
      ////////////////////////////////
      }
      ////////////////////////////////

      try
      {
        // rename source to target
        // if this fails we need to rename the old target back
        File.Move(sourceLocation.FullName, targetLocation.FullName);
      }
      catch
      {
        /////////////////////////////////////////
        if (backupLocation != null)
        {
        /////////////////////////////////////////

          // we managed to rename it once before, so this will probably work again
          File.Move(backupLocation.FullName, targetLocation.FullName);

          if (backup2Location != null)
          {
            // we've got a backup2 to unwind too
            File.Move(backup2Location.FullName, backupLocation.FullName);
          }
        ////////////////////////
        }
        ////////////////////////
        throw;
      }

      /////////////////////////////////////////////
      if (backupLocation != null)
      {
      /////////////////////////////////////////////

        // now finally get rid of the backup2
        try
        {
          backup2Location.Delete();
        }
        catch
        {
          // if this fails we can ignore it, as the main operation has succeeded.
        }
      /////////////////////////
      }
      /////////////////////////
    }
  }

Doh' I've missed the add attachments, but I'll attach now

#4 Parameter for Update/UpdatePacked/UdateNoV2tag to decide if Backup required (default true)

ScruffR — Sun, 04 Jan 2015 20:27:04 -0000

Sure, I hope this meets your standards.

Alterations in Mp3FileData.cs:

    #region public update methods
    /// <summary>
    /// Update ID3V2 and V1 tags in-situ if possible, or rewrite the file to add tags if necessary.
    /// </summary>
    /// <returns>bool true if the MP3FileData object is dirty after this</returns>

    //////////////////////////////////////////////////////////
    public CacheDataState Update(bool createBackup = true)
    //////////////////////////////////////////////////////////
    {
      if (!TagModel.IsValid)
      {
        // the standard does not allow an id3v2 tag with no frames in, 
        // so we must remove it completely.

        ////////////////////////////////////////////////////////
        return UpdateNoV2tag(createBackup);
        ////////////////////////////////////////////////////////
      }
      else
      {
        TagModel.UpdateSize();
        uint tagSizeComplete = TagModel.Header.TagSizeWithHeaderFooter;

        if (tagSizeComplete <= _audioStart && !_audioReplaced)
        {
          UpdateInSitu(tagSizeComplete);
          return CacheDataState.eClean;
        }
        else
        {
          // calculate enough padding to round final file to 2k cluster size.
          uint minLength = tagSizeComplete + _audio.NumPayloadBytes + ID3v1.TagLength;
          uint newLength = ((minLength + 2047) & 0xFFFFF800);    // round up to whole 2k cluster
          TagModel.Header.PaddingSize = newLength - minLength;

          //////////////////////////////////////////////////////////////////////////
          if (createBackup)
          {
            FileInfo bakFileInfo = null;
            string bakName = Path.ChangeExtension(_sourceFileInfo.FullName, "bak");
            bakFileInfo = new FileInfo(bakName);
            RewriteFile(bakFileInfo);
          }
          else
            RewriteFile(null);
          //////////////////////////////////////////////////////////////////////////

          return CacheDataState.eDirty;
        }
      }
    }

    /// <summary>
    /// rewrite the file and ID3V2 and V1 tags with no padding.
    /// </summary>
    /// <returns>bool true if the MP3FileData object is dirty after this</returns>

    ///////////////////////////////////////////////////////////////////////
    public CacheDataState UpdatePacked(bool createBackup = true)
    ///////////////////////////////////////////////////////////////////////
    {
      if (TagModel.Count == 0)
      {
        // the standard does not allow an id3v2 tag with no frames in, 
        // so we must remove it completely.
        // this removes the padding too, of course.

        ////////////////////////////////////////////////////
        return UpdateNoV2tag(createBackup);
        ////////////////////////////////////////////////////
      }
      else
      {
        TagModel.UpdateSize();
        TagModel.Header.PaddingSize = 0;

        /////////////////////////////////////////////////////////////////////////////
        if (createBackup)
        {
          FileInfo bakFileInfo = null;
          string bakName = Path.ChangeExtension(_sourceFileInfo.FullName, "bak");
          bakFileInfo = new FileInfo(bakName);
          RewriteFile(bakFileInfo);
        }
        else
          RewriteFile(null);
        //////////////////////////////////////////////////////////////////////////////

        return CacheDataState.eDirty;
      }
    }

    /// <summary>
    /// Update file and remove ID3V2 tag (if any); 
    /// update file in-situ if possible, or rewrite the file to remove tag if necessary.
    /// </summary>
    /// <returns>bool true if the MP3FileData object is unusable after this</returns>

    //////////////////////////////////////////////////////////////////////// 
    public CacheDataState UpdateNoV2tag(bool createBackup = true)
    ////////////////////////////////////////////////////////////////////////

    {
      if (_audioStart == 0 && !_audioReplaced)
      {
        // no v2 tag to start with; just update v1 tag
        UpdateInSituNoV2tag();
        return CacheDataState.eClean;
      }
      else
      {
        ///////////////////////////////////////////////////////////////////////////////
        if (createBackup)
        {
          FileInfo bakFileInfo = null;
          string bakName = Path.ChangeExtension(_sourceFileInfo.FullName, "bak");
          bakFileInfo = new FileInfo(bakName);
          RewriteFile(bakFileInfo);
        }
        else
          RewriteFile(null);
        ///////////////////////////////////////////////////////////////////////////////

        return CacheDataState.eDirty;
      }
    }
    #endregion

    #region private update methods

provide a nuget package

Andrew Pearmund — Sun, 04 Jan 2015 17:24:26 -0000

I've been meaning to do this for a while. Would anyone use it?

#4 Parameter for Update/UpdatePacked/UdateNoV2tag to decide if Backup required (default true)

Andrew Pearmund — Sun, 04 Jan 2015 17:18:52 -0000

That sounds useful.
Can you send me your code changes, maybe by attaching them here?
Cheers.

Parameter for Update/UpdatePacked/UdateNoV2tag to decide if Backup required (default true)

ScruffR — Sun, 04 Jan 2015 15:47:56 -0000

I've added some code to allow to suppress backuo creation when updating tags.
This would be nice if it found its way into thw official version too.