Dominic Burford - Professional Profile

option batch abort
option confirm off 
option transfer binary
open ftp://mytestenvironment:mypassword
cd /site/wwwroot
synchronize remote "C:\Builds\TFS\MyWebApp\Latest" /site/wwwroot
close 
exit

1. Stop the Azure web site (Powershell script)
2. Deploy the latest changes (using WinSCP)
3. Start the Azure website (Powershell script)

octo.exe pack --id MyWebApp --version %1 --basePath "C:\Builds\TFS\MyWebApp\Latest\websharelatest" --outFolder outputfolder

octo.exe push --package=outputfolder\MyWebApp.%1.nupkg --overwrite-mode=OverwriteExisting --server=https://mydomain.octopus.app --apiKey=API-QWERTY123456 --debug --LogLevel=debug

• Software Development
• Quality Assurance
• IT Operations

What makes a good DevOps tool?

What makes for a good CI / CD pipeline?

• Repeatable, reliable, consistent: This is the mantra for a good pipeline. It cannot be overstated how important these attributes are. These are the cornerstones for a good pipeline.

• Automation: As far as possible, the entire pipeline should be automated with no manual intervention. Other than manually triggering certain events (such as your deployment into production), the steps involved in your pipelines should all be capable of running without the need for human intervention.

Summary

public override StartCommandResult OnStartCommand(Intent intent, StartCommandFlags flags, int startId)
{
  //how do we execute async code from inside this method?
}

public override StartCommandResult OnStartCommand(Intent intent, StartCommandFlags flags, int startId)
{
    base.OnStartCommand(intent, flags, startId);
    Task.Run(async () => { await this.InitialiseJourney(); });
            
    Task.Run(async () => { await this.StartJourneyTracking(); });
    return StartCommandResult.NotSticky;
}

/// <summary>
/// Deserialise a LINQ expression tree
/// </summary>
public Remote.Linq.Expressions.Expression DeserialiseRemoteExpression<TExpression>(string json) where TExpression : Remote.Linq.Expressions.Expression
{
    JsonSerializerSettings serializerSettings = new JsonSerializerSettings().ConfigureRemoteLinq();
    Remote.Linq.Expressions.Expression result = JsonConvert.DeserializeObject<TExpression>(json, serializerSettings);
    return result;
}

/// <summary>
/// Serialise a remote LINQ expression tree
/// </summary>
public string SerialiseRemoteExpression<TExpression>(TExpression expression) where TExpression : Remote.Linq.Expressions.Expression
{
    JsonSerializerSettings serializerSettings = new JsonSerializerSettings().ConfigureRemoteLinq();
    string json = JsonConvert.SerializeObject(expression, serializerSettings);
    return json;
}

/// <summary>
/// Convert the specified Remote.Linq Expression to a .NET Expression
/// </summary>
public System.Linq.Expressions.Expression<Func<T, TResult>> ToLinqExpression<T, TResult>(Remote.Linq.Expressions.LambdaExpression expression)
{
    var exp = expression.ToLinqExpression();
    var lambdaExpression = System.Linq.Expressions.Expression.Lambda<Func<T, TResult>>(exp.Body, exp.Parameters);
    return lambdaExpression;
}

const int permissionid = 1;
Expression<Func<PermissionEntities, List<PermissionEntity>>> expr1 = m => m.Permissions.FindAll(q => q.PermissionId == permissionid);

var serialised = SerializerManager().SerialiseRemoteExpression(expr1.ToRemoteLinqExpression());

/// <summary>
/// Return the specified permissions from the remote expression
/// </summary>
public PermissionModels GetPermissionsDynamic(string payload)
{
    if (string.IsNullOrEmpty(payload)) return null;
    //create an empty default permission model
    PermissionModels result = new PermissionModels();
    //de-serialise back into a Remote.Linq Expression
    Remote.Linq.Expressions.LambdaExpression expression = 
    SerializerManager().DeserialiseRemoteExpression<Remote.Linq.Expressions.LambdaExpression>(payload) as LambdaExpression;

    //convert the Remote.Linq Expression into a .NET Expression
    var localexpression = SerializerManager().ToLinqExpression<PermissionEntities, List<PermissionEntity>>(expression);

    //grab all the permissions from the DB
    PermissionEntities permissions = this.Data.GetPermissions();
            
    //compile and invoke the expression
    var compiled = localexpression.Compile();
    var matches = compiled.Invoke(permissions);

    //if no matches were found then just return the default object with no items
    if (matches == null || !matches.Any()) return result;

    return matches
}

[TestMethod]
public void GetPermissionsDynamicTests()
{
    //Arrange
    const int permissionid = 1;
    PermissionsService service = new PermissionsService();
    Expression<Func<PermissionEntities, List<PermissionEntity>>> expr1 = m => m.Permissions.FindAll(q => q.PermissionId == permissionid);

    var serialised = SerializerManager().SerialiseRemoteExpression(expr1.ToRemoteLinqExpression());

    //Act
    var results = service.GetPermissionsDynamic(serialised);

    //Assert
    Assert.IsNotNull(results);
    Assert.IsNotNull(results.Permissions);
    Assert.IsTrue(results.Permissions.Any());
    Assert.IsNotNull(results.Permissions.Find(q => q.PermissionId == permissionid));
}

Quote:

No subscription found in the context. Please ensure that the credentials you provided are authorized to access the Azure subscription then run Connect-AzAccount to login.

cls

$ResourceGroupName = "MyWebAppGroup"
$Name = "MyWebApp"

"Stopping web application " + $Name

"ResourceGroupName: " + $ResourceGroupName
"Name: " + $Name

$SubscriptionId = "xxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxx"
"SubscriptionId is: " + $SubscriptionId

# from the Azure AD app registration 
$clientSecret = "xxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxx"
$azureAplicationId = "xxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxx"
$azureTenantId= "xxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxx"
$azurePassword = ConvertTo-SecureString $clientSecret -AsPlainText -Force
$psCred = New-Object System.Management.Automation.PSCredential($azureAplicationId , $azurePassword)

# login to Azure and set the current context
Connect-AzAccount -Credential $psCred -TenantId $azureTenantId -ServicePrincipal 
Set-AzContext -Subscription $SubscriptionId

Stop-AzWebApp -ResourceGroupName $ResourceGroupName -Name $Name

"Finished"

Quote:

Azure Cognitive Search is the only cloud search service with built-in AI capabilities that enrich all types of information to easily identify and explore relevant content at scale.

search=
searchMode=
searchFields=
queryType=
$skip=
$top=

$filter=
$orderby=
$select=

dotnet build MyProject.csproj --configuration Release /p:Version=%1

<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>netcoreapp3.1</TargetFramework>
    <!--Need to update the version number below-->
    <Version>1.0.0.0</Version>
  </PropertyGroup>
</Project>

cls

Write-Host "Versioning started"

"Sources directory " + $Env:BUILD_SOURCESDIRECTORY
"Build number " + $Env:BUILD_BUILDNUMBER

$csprojfilename = $Env:BUILD_SOURCESDIRECTORY+"\MyProject.csproj"
"Project file to update " + $csprojfilename

[xml]$csprojcontents = Get-Content -Path $csprojfilename;

"Current version number is" + $csprojcontents.Project.PropertyGroup.Version

$oldversionNumber = $csprojcontents.Project.PropertyGroup.Version

$csprojcontents.Project.PropertyGroup.Version = $Env:BUILD_BUILDNUMBER
$csprojcontents.Save($csprojfilename)

"Version number has been udated from " + $oldversionNumber + " to " + $Env:BUILD_BUILDNUMBER

Write-Host "Finished"

@echo off
cls

"C:\Program Files (x86)\WinSCP\WinSCP.com" /script=ftpDeployServices.ftp

option batch abort
option confirm off 
option transfer binary
open ftp://myusername:mypassword@mydomain.ftp.azurewebsites.windows.net/site/wwwroot
cd /site/wwwroot
synchronize remote -delete <mylocalfolder> /site/wwwroot
close 
exit

INFORMATION - 2019-12-24 - This is a log message
ERROR - 2019-12-24 - Something went wrong
INFORMATION - 2019-12-24 - This is another log message

INFORMATION - 2019-12-24 - User Joe has logged onto the system

LogType
INFORMATION

Created
2019-12-24 10:45

Message
User has logged onto the system

Properties
{ "username": "Joe" }

protected void LogMessage(string message, LogLevelTypes loglevel, Dictionary<string, string> properties = null)
{
  //write the log entry to the log table
}

Quote:

The Transport Layer Security (TLS) protocol is an industry standard designed to help protect the privacy of information communicated over the Internet. TLS 1.2 is a standard that provides security improvements over previous versions. TLS 1.2 will eventually be replaced by the newest released standard TLS 1.3 which is faster and has improved security

<configuration>
 <runtime>
  <AppContextSwitchOverrides value="Switch.System.Net.DontEnableSystemDefaultTlsVersions=false"/>
 </runtime>
</configuration>

<system.web>
 <compilation targetFramework="x.y.z" />
 <httpRuntime targetFramework="x.y.z" /> <-- this is the important one!
</system.web>

public static IEnumerable<IEnumerable<T>> GetChunk<T>(this IEnumerable<T> source, int chunksize)
{
    if (chunksize <= 0 || source == null) yield return null;
    var pos = 0;
    while (source.Skip(pos).Any())
    {
        yield return source.Skip(pos).Take(chunksize);
        pos += chunksize;
    }   
}

[TestMethod]
public void GetChunk1000Tests()
{
    const int waypointcount = 1000;

    //Arrange - fetch dummy data for the test
    var journey = ListExtensionsTests.GetTaskTrackedJourneyForUnitTest(waypointcount);

    Assert.IsNotNull(journey);
    Assert.IsNotNull(journey.Waypoints);
    Assert.IsNotNull(journey.Waypoints.Waypoints);
    Assert.IsTrue(journey.Waypoints.Waypoints.Any()); 

    Console.WriteLine($"ChunkCount: {ListExtensionsTests.ChunkCount}");
    Console.WriteLine($"Number of waypoints: {journey.Waypoints.Waypoints.Count}");

    Assert.IsTrue(journey.Waypoints.Waypoints.Count == waypointcount);
    
    //Act - chunk the list of waypoints        
    var result = journey.Waypoints.Waypoints.GetChunk(500);

    Assert.IsNotNull(result);

    var enumerable = result.ToList();
    Console.WriteLine($"Number of chunks: {enumerable.Count()}");

    int incrementalwaypointcount = 0;

    //we can now iterate through the chunked list 
    foreach (var item in enumerable)
    {
        Console.WriteLine($"Number of chunks in list {item.Count()}");
        incrementalwaypointcount += item.Count();
    }

    Assert.AreEqual(waypointcount, incrementalwaypointcount);
}

Predicate<T>

Func<T, bool>

public class Car
{
  public string Colour { get; set; }
  public int EngineSize { get; set; }
}

var data = new DataService();
List<Car> = data.GetAllRegisteredCars(new DateTime(2019, 01, 01);

var matches1 = cars.FindAll(p => p.EngineSize == 1600);
var matches2 = cars.FindAll(p => p.Colour == "Blue");

public static class PredicateFilters
{
  public static Predicate<Car> FindBlueCars = (Car p) => p => p.Colour == "Blue";
  public static Predicate<Car> Find1600Cars = (Car p) => p => p.EngineSize == 1600;

}

var matches1 = cars.FindAll(PredicateFilters.Find1600Cars);
var matches2 = cars.FindAll(PredicateFilters.FindBlueCars);

public interface IPredicateValue<T>
{
  T GetValue(List<T> list, Predicate<T> filter);
  List<T> GetValues(List<T> list, Predicate<T> filter);
  int GetCount(List<T> list, Predicate<T> filter);
}

public class CarPredicate : IPredicateValue<Car>
{
    public Car GetValue(List<Car> list, Predicate<Car> filter)
    {
        if (list == null || !list.Any() || filter == null) return null;
        return list.Find(filter);
    }

    public List<Car> GetValues(List<Car> list, Predicate<Car> filter)
    {
        if (list == null || !list.Any() || filter == null) return null;
        return list.FindAll(filter);
    }

    public int GetCount(List<Car> list, Predicate<Car> filter)
    {
        if (list == null || !list.Any() || filter == null) return 0;
        return list.FindAll(filter).Count;
    }
}

//fetch all registered cars for the current year
var data = new DataService();
List<Car> = data.GetAllRegisteredCars(new DateTime(2019, 01, 01);

//filter the cars on just the blue ones
var predicatevalue = new CarPredicate();
var blueCars = predicatevalue.GetValue(data, PredicateFilters.FindBlueCars);

public async Task<string> Get(string subscriber, string trackertype)
{
  var response = await this.GetData(subscriber, trackertype);
  return response;
}

[TestMethod]
public async Task GetVehicleTests()
{
  //Arrange
  TrackerController controller = new TrackerController();

  //Act
  string subscriber = "testsubscriber";
  string vehicle = "testvehicle";    
  var response = controller.Get(subscriber, vehicle);

  //Assert
  Assert.IsNotNull(response);
  Assert.IsNotNull(response.Result.ToString());
}

[TestMethod]
public async Task GetVehicleTests()
{
  //Arrange
  TrackerController controller = new TrackerController();

  //Act
  string subscriber = "testsubscriber";
  string vehicle = "testvehicle";    
  var response = await controller.Get(subscriber, vehicle);

  //Assert
  Assert.IsNotNull(response);
  Assert.IsNotNull(response.ToString());
}

public async Task<string> Get(string subscriber, string trackertype)
{
  var response = await this.GetData(subscriber, trackertype).ConfigureAwait(false);
  return response;
}

public class WebTasksController : BaseController
{
  public WebTasksController()
  {
  }

  public string WebGetData(string queryname, string queryterms)
  {
  }
}

[HttpGet]
[EnableCors(origins: "*", headers: "*", methods: "*")]
public string WebGetData(string queryname, string queryterms)
{
}

[DataContract]
public class WebQueryTasks
{
    [DataMember]
    public Dictionary<string, object> QuerySearchTerms { get; set; }

    /// <summary>
    /// Default constructor
    /// </summary>
    public WebQueryTasks()
    {
        this.QuerySearchTerms = new Dictionary<string, object>();
    }
}

{"QuerySearchTerms":{"email":"test@mycompany.co.uk"}}

var user = GetUser(emailaddress);
WebQueryTasks query = new WebQueryTasks();
query.QuerySearchTerms.Add("userid", user.Id);
query.QuerySearchTerms.Add("journeydate", Datetime.Now);
string queryterms = ManagerHelper.SerializerManager().SerializeObject(query);

WebQueryTasks query = ManagerHelper.SerializerManager().DeserializeObject<WebQueryTasks>(queryterms);
if (query == null || !query.QuerySearchTerms.Any())
{
  throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest, new HttpError("Unable to deserialise search terms.")));
}

object temp;
string webResults;
switch (queryname.ToLower())
{
  case WebTasksTypeConstants.GetCompanyByName:
    webResults = this._userService.GetQuerySearchTerm("name", query);
    temp = this._companiesService.Find(webResults);
    break;
  case WebTasksTypeConstants.GetCompanyById:
    webResults = this._userService.GetQuerySearchTerm("companyid", query);
    int companyId = Convert.ToInt32(webResults);
    temp = this._companiesService.Find(companyId);
    break;
  default:
    throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest, new HttpError($"Unknown query type {queryname}.")));
}

var result = ManagerHelper.SerializerManager().SerializeObject(temp);
return result;

[HttpGet]
[EnableCors(origins: "*", headers: "*", methods: "*")]
public string WebGetData(string queryname, string queryterms)
{
  WebQueryTasks query = ManagerHelper.SerializerManager().DeserializeObject<WebQueryTasks>(queryterms);
  if (query == null || !query.QuerySearchTerms.Any())
  {
    throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest, new HttpError("Unable to deserialise search terms.")));
  }

  object temp;
  string webResults;
  switch (queryname.ToLower())
  {
    case WebTasksTypeConstants.GetCompanyByName:
      webResults = this._userService.GetQuerySearchTerm("name", query);
      temp = this._companiesService.Find(webResults);
      break;
    case WebTasksTypeConstants.GetCompanyById:
      webResults = this._userService.GetQuerySearchTerm("companyid", query);
      int companyId = Convert.ToInt32(webResults);
      temp = this._companiesService.Find(companyId);
      break;
    default:
      throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.BadRequest, new HttpError($"Unknown query type {queryname}.")));
  }

  var result = ManagerHelper.SerializerManager().SerializeObject(temp);
  return result;
}

What is Asynchronous Programming?

var myList = new List<string>();
myList.Add("item1");
myList.Add("item2");
myList.Add("item3");
myList.Remove("item1");

Asynchronous programming with C#

public async Task<HttpResponseMessage> PostData(string url, HttpContent content)
{
    using (var client = new HttpClient())
    {
        return await client.PostAsync(new Uri(url), content);
    }
}

var response = await PostData(url, content);

public async Task<string> GetData(string url)
{
    using (var client = new HttpClient())
    {
        using (var r = await client.GetAsync(new Uri(url)))
        {
            string result = await r.Content.ReadAsStringAsync();
            return result;
        }
    }
}

string response = await GetData(url);
if (!string.IsNullOrEmpty(response))
{
  //de-serialise the string into an object here
}

Key takeaways

dotnet publish -c release

Quote:

a legacy system is an old method, technology, computer system, or application program "of, relating to, or being a previous or outdated computer system"