The AppLife Update Blog

  • Inserting Raw Xml During an Update

    The Change Xml Node action can be used to add content to an Xml Node, and it can also insert additional, or raw Xml into a file.  To insert raw Xml, uncheck the option to Use Xml encoding in replacement text.

    image

     

    Here’s an example of when this feature comes in handy.  The objective is to insert two new entries into the web.config assemblyBinding node.  We can replace the entire content of the target node as raw Xml.  After an update, we end up with:

     

    Non - Encoded Insert

     

    Here’s what is inserted if we do not uncheck the box:

     

    Encoded Insert

     

    Clearly not the desired result.

    Posted at 12 January, 2016 | By :Brian Haas | Categories : AppLife Update |
  • Introducing AppLife Update 5.2

    AppLife Update 5.2 was released today, along with AppLife Server 1.1.  Notable features include:

    • Select Server Side Access Control Lists During Publishing

      AppLife Server Access Control Lists can be selected from Make Update during the update publishing process.

    • Install .Net 4.6 Framework Action

      Detect and install the the .Net Framework 4.6 during application updates.

    • Improved Change XML Node Action

      Replace raw inner Xml with the Change Xml Node action.

    Posted at 20 August, 2015 | By :Brian Haas | Categories : AppLife Update |
  • GO Statements in Run SQL Action

    What’s in a GO statement?  Quite a bit actually.  Contrary to popular belief, GO is not actually part of T-SQL.  It is a command recognized by the sqlcmd and osql utilities and the SQL Server Management Studio Code editor.  When we created the Run SQL Query update action, we included parsing on GO during the update build process, which allowed users to execute their migration scripts when including them as a .sql file.  This works nicely for pure SQL.  However, when SQL is inserted into the action editor, it is parsed real-time as the update is executing. In this context, the the SQL was passed directly into a SQLCommand object and executed.  GOs don't fly there.  So why wouldn't one just put their SQL into a .sql file and let the build process parse the GO statements?  Shared Property expansions.  If you want to use Shared Property information as part of your SQL input, things became difficult.  With AppLife Update 5.1, we’ve added GO parsing to the update engine and what was once difficult, is now quite easy. 

    image

    Posted at 1 May, 2015 | By :Brian Haas | Categories : AppLife Update |
  • Introducing AppLife Update 5.1

    AppLife Update 5.1 was released today. Some new features added includes:

     

    • Improved Run SQL Query Action
    • The new Run SQL Query action now supports the use of the GO statement in SQL added directly to the action editor.  GO has always been supported in linked query files, but not in directly entered SQL text.  This is significant as the only place Shared Properties are supported is within SQL entered directly in the action editor.

    • Pre/Post Build Script Update Version Variable Definition
    • Pre/Post build scripting now has access to the Update Version being built within the scripts.  This is especially useful when local paths include the version being built and scripting around those file paths must take place before or after creating a new update.

    • New Shared Property Action Options
    • There are two new options when creating a Shared Property through the Set Shared Property action.  Number (double) values can now be created. Also, the Update Publish Date/Time is available to be assigned to a Shared Property.

    • New Display Property option on the Execute MSI Action
    • The text displayed to the user during the execution of an MSI using the Execute MSI action is now configurable.

    • Added API Access to Update Summary Text
    • Update Summary text from any locale’ can be accessed through the Update Controller API.

    Posted at 31 March, 2015 | By :Brian Haas | Categories : AppLife Update |
  • Replicate Updates Locally

    In situations where there are many deployed systems located on the same local network combined with a need to minimize bandwidth utilized in retrieving application updates it is advantageous to provide a means to download update packages only once for everyone. With a new feature of AppLife Update 5.0, creating this ability is quite easy.

    After an Update Controller checks for and downloads available updates, you can now save the downloaded package(s) and Director.Xml file to a local folder by calling the Update Controllers SaveUpdatesToLocal method.

    As an example, let’s modify the C# Simple Quick Start project that ships with AppLife Update to first check a local folder for updates before checking the public location. Any updates downloaded from the public location will be copied locally for other local systems to find. To accomplish this, we’ll add a few Main form variables to hold the Public and Local update locations.

    public partial class Form1 : Form {
     
      private string mPublicUpdatePath = @"http://www.kin…/SaveToLocalExample";
      private string mLocalUpdatePath = @"P:\Updates\SaveToLocalExample";
     

    This Quick Start uses the UpdateDisplay control to manage the update process.  To integrate with that process, we will use the CheckForUpdateCompleted and the DownloadUpdateCompleted events of the Update Controller.

    Basically we are going to initially check the local update folder for updates.  If no updates are found locally, we’ll check the public update folder.  If we find any updates in the public location, we’ll save them locally with the new SaveUpdatesToLocal method.  So here goes. 

     

    Modify the Update Controller’s default Update Location to be the local update path, and then attach to the two events.

    image

    image

     

    First, lets handle the CheckForUpdateCompleted event.  This event fires whenever the Update Controller completes an update check.  If the private location was checked, we’ll just switch to the public location and check again.

     

    private void updateController1_CheckForUpdateCompleted
    	(object sender, CheckForUpdateCompletedEventArgs e) {
     
    	UpdateController c = sender as UpdateController;
     
    	if(c.UpdateLocation == mLocalUpdatePath) {
    		//we checked the local path.  If we didnt find any
    		//updates, lets check the public path
    		c.UpdateLocation = mPublicUpdatePath;
    		c.CheckForUpdateAsync();
    	}
    }

     

    And then finally, in the DownloadUpdateCompleted event, we’ll look to see if the update that was just downloaded came from the public location.  If so, we’ll save it to the local folder using the new method.

    private void updateController1_DownloadUpdateCompleted
    	(object sender, AsyncCompletedEventArgs e) {
     
    	UpdateController c = sender as UpdateController;
     
    	if(c.UpdateLocation == mPublicUpdatePath) {
    		//downloaded an update from the public path. Save it locally
    		c.SaveUpdatesToLocal(mLocalUpdatePath, false);
    	}
    }

     

    If multiple update packages were downloaded as a chain collection, all of the update packages will be saved by the SaveUpdatesToLocal method.

    Posted at 1 March, 2015 | By :Brian Haas | Categories : AppLife Update |