I recently had to handle a particular request from a client: They had sent out a newsletter that linked to their site, but had sent the wrong URL. As such, they needed the site to redirect the bad URL to the correct one. The bad URL linked to a page that passed along query string parameters. A simple request and a simple fix, right? Well, as I delved into the site’s rewrite rules, I quickly found out that the URL I needed to match was not matching. Worse still, it was making the site break! As it turns out, writing a query string rewrite rule takes a little more effort than simply doing an exact match on the URL itself.

First Attempt

Here’s the rule I started out with. I cracked open my separated rewrite rules config file and got to writing. Here’s what I ended up with at first (with details changed to protect the innocent):

<rule name="Redirect Incorrect URL" stopProcessing="true">
  <match url="^wrong-page?foo=11&bar=20$" />
  <action type="Redirect" url="correct-page" appendQueryString="false" />
</rule>

If I didn’t have a complex query string (i.e. one with multiple parameters), or any query string at all for that matter, I’d be done. Instead my local development copy of the site went down! It was throwing an HTTP 500 error and nothing more. (Incidentally, this is why you never make changes, even simple ones, on production!) What gives?

Encoding the Ampersands and Splitting the Query String

In our query string rewrite rule, the first change is to encode the ampersands. Our web application in IIS was tripping up on those characters. We also need to move the query string. IIS reads the URL well enough in the <match> element, but the query string is a separate piece altogether, and needs to be moved to the <conditions> element instead.

<rule name="Redirect Incorrect URL" stopProcessing="true">
  <match url="^wrong-page$" />
  <action type="Redirect" url="correct-page" appendQueryString="false" />
  <conditions>
    <add input="{QUERY_STRING}" pattern="^foo=11&amp;bar=20$" />
  </conditions>
</rule>

We’re good now right? Wrong! While the site was no longer crashing down on me, the rewrite rule was not matching despite entering that exact URL. There was one smaller change I needed to make in order to get this query string rewrite rule matching.

Eliminating the Money and Making it Work

Our query string rewrite rule didn’t match because we specified the end-of-string regular expression symbol in our <match> element. IIS seems to ignore anything past that symbol, including items in the condition, despite my initial thinking. Once I got rid of the $ symbol, it all fell into place and began working. Here is the final, working query string rewrite rule:

<rule name="Redirect Incorrect URL" stopProcessing="true">
  <match url="^wrong-page" />
  <action type="Redirect" url="correct-page" appendQueryString="false" />
  <conditions>
    <add input="{QUERY_STRING}" pattern="^foo=11&amp;bar=20$" />
  </conditions>
</rule>

Summary

In this case, a simple request led me on a little journey through the various workings of IIS rewrite. Despite working with it for some time now, I still managed to come across something new!

The post Matching Complex Query String Rewrite Rule in IIS appeared first on Falafel Software Blog.

Sitefinity gives you a lot of power. One of the many tools at your disposal is the ability to enter HTML in Content Blocks (either inline on a page, or in the Content Block type that can be shared among multiple pages). A common gotcha with new applications, however, is how Sitefinity filters these. Content filters exist out of the box in Sitefinity to presumably do two things:

• Standardize content entry (i.e. transform all <i> tags to <em> tags)
• Security precaution (i.e. strip out <script> tags)

While both of these traits are admirable on paper, a lot of the time they can get in the way. In our normal Sitefinity development and design workflows, we already trust every user with backend access to not enter malicious scripting, etc. Therefore when we set up a new Sitefinity application, one of the first things we do is disable these content filters so that we can work unhindered.

The Problem

Here’s an example of a Content Block’s HTML content getting changed on the fly in Sitefinity, due to the existing content filters. This scenario occurs both when attempting to edit content blocks on pages and when attempting to edit Content Blocks in Content > Content blocks.

The Fix

These content filters can be frustrating if you don’t catch them or don’t know why they’re happening! Luckily they’re easy enough to disable.

• Hop on over to Administration > Settings, click Advanced, then Appearance. Within your site, you can go directly to this screen by visiting http://www.example.com/Sitefinity/Administration/Settings/Advanced/Appearance.
• Here you will find three settings: RadEditor filters for Content block widget, Rad Editor’s content filters, and Rad Editor strip formatting options.
• Change all of these settings to “None” (without the quotes).
• Click “Save changes.”

Content Entry Unfiltered

Now that we’ve disabled the content filters, we can freely enter content in the Sitefinity backend without worrying about Sitefinity changing or deleting our work. As before, this applies both to content blocks on pages and to content blocks created as content items in Sitefinity proper.

Content Filters and Sitefinity Feather

The above content filter disabling practice only applies to the classic set of widgets and content. They do not apply to Sitefinity MVC Feather widgets. Feather content blocks have a separate means of filtering and formatting, which I addressed in a previous post of mine. But the content filters discussed here have no bearing on those.

Summary

Sitefinity has content filters in place to help preserve consistency and to help with security. In a lot of scenarios, these are redundant and can get in the way of content entry, design, or development. Sitefinity exposes these settings to allow for easy disabling of the content filters to allow you to go unhindered when entering content going forward.

The post Disable Content Filters in Sitefinity appeared first on Falafel Software Blog.

Company’s work with Big Bear Mountain Resort honored for the best in website creativity, design, user experience, functionality and overall presentation

 Scotts Valley, CA—February 28, 2017—Falafel Software today announced that the Big Bear Mountain Resort website, designed and built by Falafel Software has been named a 2016 Progress^® Sitefinity™ Website of the Year winner in the Tourism & Hospitality category. Since its inception in 2011, the Website of the Year awards have been recognizing Progress Sitefinity-powered websites for creativity, design, user experience, functionality and overall website presentation.

“On behalf of Progress, I would like to congratulate Falafel Software on this terrific achievement,” said Kimberly King, Vice President, Global Partners and Channels, Progress. “While the Sitefinity platform is trusted and used by thousands of customers worldwide to create and optimize customer experiences across channels, these awards honor the progressive companies that are truly setting the pace for others.”

“Congratulations to the entire Mammoth Mountain team for the award and the great achievement,” said Lino Tadros, President & CEO, Falafel Software. “Our team at Falafel enjoyed working on the site and with your talented team.  Thank you also to Progress for recognizing our quality of work and the greatness of the Big Bear Mountain Resort web site”.

More information about the contest and the winners is available on the “Website of the Year” page.

About Falafel Software

Falafel Software Inc., a Microsoft Silver Certified partner and a Telerik Platinum Partner for 14 years, has been providing custom software development, consultation, and training services worldwide since 2003. We are a 100% US-based team of Sr. Software Engineers, Marketers and UI/UX designers. Our team of Microsoft Certified Professionals will exceed your expectations when you choose any of our services. Our highly talented team has spoken at many of the world’s most popular development conference and we give training on the newest technology. Read our blog for development tips, tricks and advice. We offer training on Telerik & Progress Sitefinity, Kendo UI, Xamarin, and ASP.NET.

 About Progress

Progress (NASDAQ: PRGS) is a global leader in application development, empowering enterprises to build mission-critical business applications to succeed in an evolving business environment. With offerings spanning web, mobile and data for on-premise and cloud environments, Progress powers businesses worldwide, promoting success one application at a time. Learn about Progress at www.progress.com or 1-781-280-4000.

The post Falafel Software Recognized for Sitefinity Website of the Year appeared first on Falafel Software Blog.

If you’ve done software development for any length of time, you’ve likely run into a caching issue. Caching is difficult to get right, but it is so beneficial that we work with it in nearly everything we do. In the case of Sitefinity, it performs caching all over the place. As a result, many aspects of the Sitefinity experience are greatly improved. If you disabled caching for a Sitefinity site altogether, the site would slow down immensely. Sitefinity, by its nature of being a Content Management System, stores the bulk of its content in the site’s backing data store (usually a database), so it would get very chatty if it couldn’t cache. However, like with all caching, we have the issue of cache invalidation to tackle. For built-in content widgets, this is already taken care of. But what if you have a custom content widget? You’ll quickly discover that a Sitefinity page, after rendered the first time, will not re-render even if said content is updated in the backend in some form. In this post I’ll show how you can enable automatic cache busting, so that custom widget caching is implemented correctly and your pages will always update when your content does.

Example: Dynamic Content Widget Implementing Custom Widget Caching

Here we have a controller working with a dynamic content item. This kind of controller implementation for custom widget caching can apply to any dynamic content type. The only thing that has to change is the type that you pass to the caching method. Let’s have a look and break it down.

using System;
using System.Collections.Generic;
using System.Web.Mvc;
using Telerik.Sitefinity.Data;
using Telerik.Sitefinity.DynamicModules.Model;
using Telerik.Sitefinity.Services;
using Telerik.Sitefinity.Utilities.TypeConverters;
using Telerik.Sitefinity.Web;
using Telerik.Sitefinity.Web.UI.ContentUI.Contracts;

namespace SitefinityWebApp.Mvc.Controllers
{
    public class ExampleDynamicContentWidgetController : Controller, IHasCacheDependency
    {
        private Type DynamicContentType => TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.CustomModule.CustomType");

        public IList<CacheDependencyKey> GetCacheDependencyObjects()
        {
            return new List<CacheDependencyKey> { new CacheDependencyKey { Key = DynamicContentType.FullName, Type = typeof(DynamicContent) } };
        }

        protected void SubscribeToCacheDependency()
        {
            if (SystemManager.IsDesignMode || SystemManager.IsPreviewMode)
            {
                return;
            }
            IList<CacheDependencyKey> keys = GetCacheDependencyObjects();

            if (!SystemManager.CurrentHttpContext.Items.Contains(PageCacheDependencyKeys.PageData))
            {
                SystemManager.CurrentHttpContext.Items.Add(PageCacheDependencyKeys.PageData, new List<CacheDependencyKey>());
            }
            ((List<CacheDependencyKey>)SystemManager.CurrentHttpContext.Items[PageCacheDependencyKeys.PageData]).AddRange(keys);
        }

        public ActionResult Index()
        {
            SubscribeToCacheDependency();

            // Access your dynamic content here.

            return View("Default");
        }
    }
}

The first thing you should note is that you have to make your controller implement the “IHasCacheDependency” interface and implement the “GetCacheDependencyObjects” method. This is the cornerstone of custom widget caching. Inside you see we are returning a single CacheDependencyKey, and tying it to our custom content type.

“SubscribeToCacheDependency” is the method you use to wire in any of your MVC actions to the caching mechanism. Note how in our Index action the first thing we do is call it.

That’s all there is to it! Now our widget will tell any pages it is on to re-run and get fresh data, instead of being stuck with stale cached date. Custom widget caching is really that simple!

Example: News Content Widget Implementing Custom Widget Caching

This will look much like the above example, but I wanted to demonstrate how to set up caching for a built-in Sitefinity content type.

using System.Collections.Generic;
using System.Web.Mvc;
using Telerik.Sitefinity.News.Model;
using Telerik.Sitefinity.Services;
using Telerik.Sitefinity.Data;
using Telerik.Sitefinity.Web;
using Telerik.Sitefinity.Web.UI.ContentUI.Contracts;

namespace SitefinityWebApp.Mvc.Controllers
{
    public class ExampleNewsWidgetController : Controller, IHasCacheDependency
    {
        public IList<CacheDependencyKey> GetCacheDependencyObjects()
        {
            return new List<CacheDependencyKey> { new CacheDependencyKey { Type = typeof(NewsItem) } };
        }

        protected void SubscribeToCacheDependency()
        {
            if (SystemManager.IsDesignMode || SystemManager.IsPreviewMode)
            {
                return;
            }
            IList<CacheDependencyKey> keys = GetCacheDependencyObjects();

            if (!SystemManager.CurrentHttpContext.Items.Contains(PageCacheDependencyKeys.PageData))
            {
                SystemManager.CurrentHttpContext.Items.Add(PageCacheDependencyKeys.PageData, new List<CacheDependencyKey>());
            }
            ((List<CacheDependencyKey>)SystemManager.CurrentHttpContext.Items[PageCacheDependencyKeys.PageData]).AddRange(keys);
        }

        public ActionResult Index(string category)
        {
            SubscribeToCacheDependency();

            // Access News here.

            return View();
        }
    }
}

You see here that with the exception of GetCacheDependencyObjects creating a key whose type is “typeof(NewsItem)”, everything else plays out exactly the same. For built-in Sitefinity content types, you pass the type of the Model item (in this case, NewsItem) in order to configure it properly.

Refactoring Custom Widget Caching Widgets to Share Code

Since the two above are so similar, we definitely would want to refactor it. What we can do is create an abstract base class to make custom widget caching easy to implement going forward.

using System;
using System.Collections.Generic;
using System.Web.Mvc;
using Telerik.Sitefinity.Data;
using Telerik.Sitefinity.DynamicModules.Model;
using Telerik.Sitefinity.News.Model;
using Telerik.Sitefinity.Services;
using Telerik.Sitefinity.Utilities.TypeConverters;
using Telerik.Sitefinity.Web;
using Telerik.Sitefinity.Web.UI.ContentUI.Contracts;

namespace SitefinityWebApp.Mvc.Controllers
{
    public abstract class CacheDependencyController : Controller, IHasCacheDependency
    {
        protected abstract Type CachedObjectType { get; }

        public IList<CacheDependencyKey> GetCacheDependencyObjects()
        {
            var key = CachedObjectType.ToString().StartsWith("Telerik.Sitefinity.DynamicTypes.Model")
                ? new CacheDependencyKey {Key = CachedObjectType.FullName, Type = typeof(DynamicContent)}
                : new CacheDependencyKey {Type = CachedObjectType};

            return new List<CacheDependencyKey> {key};
        }

        protected void SubscribeToCacheDependency()
        {
            if (SystemManager.IsDesignMode || SystemManager.IsPreviewMode)
            {
                return;
            }
            IList<CacheDependencyKey> keys = GetCacheDependencyObjects();
            if (!SystemManager.CurrentHttpContext.Items.Contains(PageCacheDependencyKeys.PageData))
            {
                SystemManager.CurrentHttpContext.Items.Add(PageCacheDependencyKeys.PageData, new List<CacheDependencyKey>());
            }
            ((List<CacheDependencyKey>)SystemManager.CurrentHttpContext.Items[PageCacheDependencyKeys.PageData]).AddRange(keys);
        }
    }

    public class ExampleDynamicContentWidgetController : CacheDependencyController
    {
        protected override Type CachedObjectType => TypeResolutionService.ResolveType("Telerik.Sitefinity.DynamicTypes.Model.CustomModule.CustomType");

        public ActionResult Index()
        {
            SubscribeToCacheDependency();

            // Access your dynamic content here.

            return View("Default");
        }
    }

    public class ExampleNewsWidgetController : CacheDependencyController
    {
        protected override Type CachedObjectType => typeof(NewsItem);

        public ActionResult Index(string category)
        {
            SubscribeToCacheDependency();

            // Access News here.

            return View();
        }
    }
}

Our base class now handles the boilerplate code, as well as deciding the correct kind of CacheDependencyKey to create and return. Look how easy it is to slap on to any custom widget! We inherit from the abstract class, implement the CachedObjectType, and call SubscribeToCacheDependency in any action we wish to cache. Custom Widget Caching is now incredibly simple!

If you have multiple types you wish to enable, then this particular refactor won’t work. It could easily be adjusted to accept a list of Types to cache, however. GetCacheDependencyObjects would simply have to be adjusted to return the list of types, instead of the list of a single type.

With this new tool in your arsenal, you can now continue to use the power of caching in your Sitefinity site, while making sure custom widget caching is in place to bust caches and prevent your site from serving stale content.

The post On Sitefinity Custom Widget Caching appeared first on Falafel Software Blog.

EventsXD

One of our products, EventsXD experienced total failure around 5:00 am PST on Sunday while multiple conferences around the world were using the platform for their events.  Immediately, we were notified by our systems that connections to the Hosting servers and SQL Servers in Azure were down.

Azure Cloud Failure

I opened a critical support ticket with Microsoft around 6:00 am PST, gladly received a reply at 6:15 am (very fast) that Engineering is looking into it.

At this time, we started received emails and calls from angry customers that their event is down and none of the attendees or the organizers can access the event on their mobile device.

It took 6.5 hours for Azure to restore the services on “West US 2”, by that time several clients notified us that they would like a refund for their events and I am pretty sure they will not be using EventsXD again in the near future.

Lack of Redundancy

EventsXD has over 10,000 events running on its platform worldwide.  We thought we were in good hands with Microsoft Azure with adequate “Redundancy” and solid infrastructure.

Even though the support was excellent as far as timing, they did not provide ANY valuable information regarding how could that possibly happen in a Cloud platform that drives itself on “Redundancy” and solid infrastructure.

To say the least, we are very concerned about our investment and reliance on the Azure Cloud after this instance.  This is the 3rd time in 18 months that Azure fails and causes catastrophic results to critical apps running on the platform.

Difficult Decision

Is it time to move EventsXD and other projects to AWS or Google Cloud?

The post Disappointing Azure Cloud Failures appeared first on Falafel Software Blog.

In a previous post, I went over how you can easily create a custom code-behind C# class for any Widget Template in Sitefinity. Give that post a quick once-over, as this post builds upon that one. For built-in Sitefinity content items, accessing the data is pretty straightforward (see the previously-linked post): You grab the container, iterate over the items (even in the case of a single detail item), and then work with the data to make customizations to the page. For Dynamic Content Detail Widget templates, however, things work differently. You can still get access to your data, but if you observe the content of a detail widget template for dynamic content, you’ll will find only a DynamicDetailContainer to work with. How do you access your item? Let’s find out!

Binding to DynamicDetailContainer’s DataBound Event

This first step is more-or-less identical to how we’ve done this before. We find our DynamicDetailContainer and assign a method to its DataBound event:

using System;
using System.Linq;
using System.Web.UI;
using Telerik.Sitefinity.DynamicModules.Model;
using Telerik.Sitefinity.DynamicModules.Web.UI.Frontend;
using Telerik.Sitefinity.Model;

namespace SitefinityWebApp.Custom
{
    public class CustomCodeBehind : UserControl
    {
        protected override void OnInit(EventArgs e)
        {
            base.OnInit(e);
            DynamicDetailContainer detailContainer = (DynamicDetailContainer)FindControl("detailContainer");
            if (detailContainer != null)
            {
                detailContainer.DataBound += DetailContainerDataBound;
            }
        }

        private void DetailContainerDataBound(object sender, EventArgs e)
        {
            throw new NotImplementedException();
        }
    }
}

You can see how similar this is to the one we’ve created before! The only difference in the case of a Dynamic Content Detail Widget’s DynamicDetailContainer event is that we bind to a method whose parameters are of type “object” and “EventArgs.” Previously we bound to a method whose second parameter was “RadListViewItemEventArgs.”

Getting to Your DynamicContent Object

Now that we’re in our DataBound method, we need to reach out to our object we’re binding to. Since this container doesn’t iterate on DataBound, we have to access the entire collection of bound objects. For a Dynamic Content Detail Widget, this collection will always have just one object in play. The DynamicDetailContainer will possess this single-item collection, and the container itself is passed to the event via the “sender” parameter. Here’s what a complete example looks like:

using System;
using System.Linq;
using System.Web.UI;
using Telerik.Sitefinity.DynamicModules.Model;
using Telerik.Sitefinity.DynamicModules.Web.UI.Frontend;
using Telerik.Sitefinity.Model;

namespace SitefinityWebApp.Custom
{
    public class CustomCodeBehind : UserControl
    {
        protected override void OnInit(EventArgs e)
        {
            base.OnInit(e);
            DynamicDetailContainer detailContainer = (DynamicDetailContainer)FindControl("detailContainer");
            if (detailContainer != null)
            {
                detailContainer.DataBound += DetailContainerDataBound;
            }
        }

        private void DetailContainerDataBound(object sender, EventArgs e)
        {
            DynamicDetailContainer detailContainer = (DynamicDetailContainer)sender;
            DynamicContent[] dynamicItems = (DynamicContent[])detailContainer.DataSource;
            DynamicContent dynamicItem = dynamicItems.FirstOrDefault();
            if (dynamicItem == null)
            {
                return;
            }
            
            // Perform customizations with dynamicItem here.
        }
    }
}

We first cast “sender” to the type DynamicDetailContainer. Dynamic Content Detail Widget’s DetailContainer DataBound event always passes this. This object has a “DataSource” property where the collection of DynamicContent items, stored as an array, can be found. From there it’s a simple matter of LINQing out our single object, verifying we got it, then performing whatever customizations we desire based off of our bound object.

Working with your DynamicContent Object

As expected, the Dynamic Content Detail Widget’s DetailContainer works with the live, published version of the item. It would be really weird if it didn’t! Sitefinity binds this item to the container to show the live, published data, and now the power’s in your hands as well. You can work with this item the way you would work with DynamicContent items in any other programming context: Fetch custom fields, get related data, etc. You could technically re-fetch it too, using the given ID, but since the container already has the object for you that would be redundant.

And that’s it! This functionality took me a little digging to find, but now you can find it easily here. Working with Dynamic Content Detail Widget code-behinds is as easy as working with any widget template code-behind, once you know how to get to the item. Now you do!

The post Dynamic Content Detail Widget Templates in Sitefinity appeared first on Falafel Software Blog.

This is post 17 of 17 in the series “Google Cloud for the .NET Developer”

We previously looked at how you can use the WebAuthenticationBroker to allow end users to authorize a UWP app to access their Google account information. In this post we’ll complete the sample by describing how to authorize a UWP app to access Google Cloud Product services.

To demonstrate this, we’ll recreate the ASP.NET MVC sample that logins in a user, grabs their profile image, and uploads that image to Google Storage.

However, just like in our previous sample, we don’t have any helper libraries we can use, because as of this writing the Google Cloud SDK does not yet natively support UWP. Fortunately, we can always access the services via REST, so let’s get to it.

Authorization Workflow

Just like in our MVC sample, we need a way to authorize our app to access the services in our GCP account so that it can make the appropriate changes, in this case, uploading an image to Google Storage.

However, unlike our MVC sample, we are unable to use the same Web Server OAuth Workflow because it would require that we issue a POST containing the client secret, and this request could be hijacked by a malicious user, compromising our security.

Instead, we need to use a different OAuth workflow for Service Accounts which uses a JSON Web Token (JWT) to authorize the request. The JWT contains the scope of your request, and needs to be signed with your private key, which is issued when you create credentials in the Google API Console.

Recall that when you create a Service Account in the console (in this case we want to use the option for P12), you are immediately served a file containing your private key.

This is the only time that key is available, so be sure to keep that key safe, or you will have to delete it and create a new one.

Once you’ve created the JWT, having signed it with your private key, you simply POST this request to the Google authorization endpoint, and you will be returned a response containing a Bearer token that you can use to make authorized requests to the scopes you requested in the JWT.

Before we look at the code, let’s take a moment to review an important consideration regarding security for your app.

Security Considerations

Because the request needs to be signed, your app must have access to the file containing your private key, in this case the P12 file issued when you created the Service Account you’ll be using to authenticate your app.

Although you can simply include this file in your app, you probably don’t want to do this for any scenario other than testing locally. Distributing your app with the key file means anyone could use it to sign requests on behalf of your app!

A slightly better idea may be to embed the file as a resource into your app, so that it’s not freely available as a separate file. This is what we’re doing in this example. However, a malicious user could certainly still decompile your app and retrieve the key that way. Encryption and obfuscation is probably a good idea, especially in specific scenarios, such as internal business apps, where you can control access to devices where your app is deployed.

Ideally, however, you probably want to setup a proxy web service to handle requests to the GCP service, and use the server authentication from our previous example to perform the GCP service operations. This way your server can be authorized entirely outside your app, protecting your key from being stolen and giving you full control of your apps content workflow.

That being said, I am not a security expert by any means, and would love to hear thoughts from how to best protect a UWP app from others in the comments. This sample is meant only to serve as a simple example of accessing GCP in a UWP app, so please use with care.

Now that we understand the workflow and security needs, let’s dive into the code!

Creating a JWT in UWP Apps

The trickiest part of putting this sample together was definitely creating the JWT token, because the token has to be signed, and cryptography isn’t something I personally know a lot about.

Fortunately, I found a helpful sample from developer Ilya Melamed who wrote a post about Authenticating with Google Service Account in C# (JWT). This sample is for the full .NET framework (such as WPF apps) and many of the classes used are not available for UWP. However, it was a useful starting point which I used to expand to UWP.

X509Certificate2

The key part of Ilya’s sample is the use of the X509Certificate2 class which can load the P12 key file from Google. Although UWP does not have this class natively in the framework, there is a nuget package available which adds these classes: System.Security.Cryptography.X509Certificates

With this we’ll be able to open the P12 key and use it to sign our JWT, so in my sample project I’ve added that key file as an embedded resource:

To open the file we extract it from the assembly as a stream, and read the contents as bytes:

var assembly = this.GetType().GetTypeInfo().Assembly;
    var stream = assembly.GetManifestResourceStream("GoogleUwpTestApp.Falafel-Test-Project-232e85f0df81.p12");
    using (var streamReader = new BinaryReader(stream))
    {
        var bytes = streamReader.ReadBytes((int) stream.Length);
                // ...
    }

This will eventually be passed to the X509Certificate2 constructor, which accepts those bytes and the password, which is “notasecret” for GCP certificates:

var certificate = new X509Certificate2(certificateBytes, "notasecret", X509KeyStorageFlags.Exportable);

Now that we have a way to sign our token, let’s create it!

Creating the Token

The header is the same for all requests, indicating the type and signing algorithm:

var header = new { typ = "JWT", alg = "RS256" };

Next we need to create the claimset, which contains our client ID, requested scopes, and other details described in the Google OAuth documentation:

var times = GetExpiryAndIssueDate();
var claimset = new
{
    iss = clientID,
    scope = scope,
    aud = "https://www.googleapis.com/oauth2/v4/token",
    iat = times[0],
    exp = times[1],
};

These components of the JWT then need to be Base64 encoded:

// encoded header
            var headerSerialized = JsonConvert.SerializeObject(header);
            var headerBytes = Encoding.UTF8.GetBytes(headerSerialized);
            var headerEncoded = Convert.ToBase64String(headerBytes);

            // encoded claimset
            var claimsetSerialized = JsonConvert.SerializeObject(claimset);
            var claimsetBytes = Encoding.UTF8.GetBytes(claimsetSerialized);
            var claimsetEncoded = Convert.ToBase64String(claimsetBytes);

            // input
            var input = headerEncoded + "." + claimsetEncoded;
            var inputBytes = Encoding.UTF8.GetBytes(input);

And finally, we use the certificate we opened to sign the token, putting it all together to get the final JWT:

// signature
            string signatureEncoded;
            try
            {
                var signatureBytes = certificate.GetRSAPrivateKey().SignData(inputBytes, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
                signatureEncoded = Convert.ToBase64String(signatureBytes);
            }
            catch (Exception ex)
            {
                signatureEncoded = string.Empty;
            }

            // jwt
            var jwt = headerEncoded + "." + claimsetEncoded + "." + signatureEncoded;

Now that we have our token, we can issue a POST to the Google authorization endpoint:

// wrap parameters in a Form object
            var content = new FormUrlEncodedContent(new[]
            {
                new KeyValuePair<string, string>("assertion", jwt),
                new KeyValuePair<string, string>("grant_type", "urn:ietf:params:oauth:grant-type:jwt-bearer")
            });

            // the url to send the POST request (from the google docs)
            var postUrl = "https://www.googleapis.com/oauth2/v4/token";

            // submit the request
            var client = new HttpClient();
            var result = await client.PostAsync(postUrl, content);
            var str = await result.Content.ReadAsStringAsync();

            dynamic parsedResult = JsonConvert.DeserializeObject(str);
            return result == null ? string.Empty : parsedResult.access_token;

And if we did everything right, we’ll get back the access token for our app, which we’ll use to authorize subsequent requests to our GCP services.

Here’s the complete GoogleJsonWebTokenHelper class for UWP:

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;

namespace GoogleUwpTestApp.Google
{
    public class GoogleJsonWebTokenHelper
    {
        private readonly string clientID;
        private readonly string scope;

        public GoogleJsonWebTokenHelper(string clientID, string scope)
        {
            this.clientID = clientID;
            this.scope = scope;
        }

        public async Task<string> GetAccessToken(string certificateFilePath)
        {
            // certificate
            var certificate = new X509Certificate2(certificateFilePath, "notasecret", X509KeyStorageFlags.Exportable);
            return await GetAccessTokenInternal(certificate);
        }

        public async Task<string> GetAccessToken(byte[] certificateBytes)
        {
            // certificate
            var certificate = new X509Certificate2(certificateBytes, "notasecret", X509KeyStorageFlags.Exportable);
            return await GetAccessTokenInternal(certificate);
        }

        private async Task<string> GetAccessTokenInternal(X509Certificate2 certificate)
        { 
            // header
            var header = new { typ = "JWT", alg = "RS256" };

            // claimset
            var times = GetExpiryAndIssueDate();
            var claimset = new
            {
                iss = clientID,
                scope = scope,
                aud = "https://www.googleapis.com/oauth2/v4/token",
                iat = times[0],
                exp = times[1],
            };

            // encoded header
            var headerSerialized = JsonConvert.SerializeObject(header);
            var headerBytes = Encoding.UTF8.GetBytes(headerSerialized);
            var headerEncoded = Convert.ToBase64String(headerBytes);

            // encoded claimset
            var claimsetSerialized = JsonConvert.SerializeObject(claimset);
            var claimsetBytes = Encoding.UTF8.GetBytes(claimsetSerialized);
            var claimsetEncoded = Convert.ToBase64String(claimsetBytes);

            // input
            var input = headerEncoded + "." + claimsetEncoded;
            var inputBytes = Encoding.UTF8.GetBytes(input);

            // signature
            string signatureEncoded;
            try
            {
                var signatureBytes = certificate.GetRSAPrivateKey().SignData(inputBytes, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
                signatureEncoded = Convert.ToBase64String(signatureBytes);
            }
            catch (Exception ex)
            {
                signatureEncoded = string.Empty;
            }

            // jwt
            var jwt = headerEncoded + "." + claimsetEncoded + "." + signatureEncoded;

            // wrap parameters in a Form object
            var content = new FormUrlEncodedContent(new[]
            {
                new KeyValuePair<string, string>("assertion", jwt),
                new KeyValuePair<string, string>("grant_type", "urn:ietf:params:oauth:grant-type:jwt-bearer")
            });

            // the url to send the POST request (from the google docs)
            var postUrl = "https://www.googleapis.com/oauth2/v4/token";

            // submit the request
            var client = new HttpClient();
            var result = await client.PostAsync(postUrl, content);
            var str = await result.Content.ReadAsStringAsync();

            dynamic parsedResult = JsonConvert.DeserializeObject(str);
            return result == null ? string.Empty : parsedResult.access_token;
        }

        private int[] GetExpiryAndIssueDate()
        {
            var utc0 = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
            var issueTime = DateTime.UtcNow;

            var iat = (int) issueTime.Subtract(utc0).TotalSeconds;
            var exp = (int) issueTime.AddMinutes(55).Subtract(utc0).TotalSeconds;

            return new[] { iat, exp };
        }
    }
}

Uploading an Image

Now that we have the token we can proceed to issue a simple POST request with the image contents we retrieve from the user, including the token in the header:

public async Task UploadImage(string url, string filename, string bucketName)
        {
            var client = new HttpClient();
            var resultStream = await client.GetStreamAsync(url);

            Byte[] bytes;
            using (var memoryStream = new MemoryStream())
            {
                resultStream.CopyTo(memoryStream);
                bytes = memoryStream.ToArray();
            }


            client.DefaultRequestHeaders.Add("Authorization", "Bearer  " + access_token);
            var uploadUri = string.Format("https://www.googleapis.com/upload/storage/v1/b/{0}/o?uploadType=media&name={1}&predefinedAcl=publicRead", bucketName, filename);

            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, uploadUri);
            request.Content = new ByteArrayContent(bytes);
            request.Content.Headers.ContentType = new MediaTypeHeaderValue("image/jpeg");
            request.Content.Headers.ContentLength = bytes.Length;

            HttpResponseMessage response = await client.SendAsync(request);
            var result = await response.Content.ReadAsStringAsync();
        }

The result is an image uploaded to the storage bucket, which we use to refresh the list, and now have a new profile image added to the ListView:

Retrieving the items from Google storage is done similarly to our MVC sample; we simply query the rest API, sending the same bearer token we already retrieved:

public async Task<StorageModel> GetStorageImages(string bucketName)
        {
            var client = new HttpClient();
            client.DefaultRequestHeaders.Add("Authorization", "Bearer  " + access_token);
            var bucketUri = string.Format("https://www.googleapis.com/storage/v1/b/{0}/o", "falafel-test-profile-images");

            var resultJson = await client.GetStringAsync(bucketUri);
            var storageResult = JsonConvert.DeserializeObject<StorageModel>(resultJson);

            return storageResult;
        }

In this case, StorageModel is just a simple C# class that encapsulates the JSON result from the call:

public class Item
    {
        public string kind { get; set; }
        public string id { get; set; }
        public string selfLink { get; set; }
        public string name { get; set; }
        public string bucket { get; set; }
        public string generation { get; set; }
        public string metageneration { get; set; }
        public string contentType { get; set; }
        public string timeCreated { get; set; }
        public string updated { get; set; }
        public string storageClass { get; set; }
        public string timeStorageClassUpdated { get; set; }
        public string size { get; set; }
        public string md5Hash { get; set; }
        public string mediaLink { get; set; }
        public string crc32c { get; set; }
        public string etag { get; set; }
    }

    public class StorageModel
    {
        public string kind { get; set; }
        public List<Item> items { get; set; }
    }

That’s all there is to it!

Wrapping Up

Although the Google Cloud SDK doesn’t yet have native support for UWP apps, it is still possible to perform any of the various operations for both Service and User accounts using plain old REST commands. Authorizing your app to access GCP Services via Service Account takes a bit more work, and you do want to be careful with your certificates, but it’s absolutely possible with a little extra work.

Hopefully we’ll start to see some UWP support in the coming months, but in the meantime, as always I hope this was helpful, and thanks for reading!

The post Using Google Services in UWP C# Apps – Part 2 appeared first on Falafel Software Blog.

This is post 16 of 17 in the series “Google Cloud for the .NET Developer”

It’s no secret that I love Windows, and especially writing UWP apps for Windows using C#. In fact I’ve written a bit about creating UWP apps in the past, so as a fan of UWP, I wanted to explore how one can leverage the Google Cloud Platform and other Google services in Windows apps.

Unfortunately, as of this writing, Google does not officially support UWP. However, this is not to say you cannot USE Google services in your app; it only means that the SDKs available to simplify accessing these services have not yet been updated to support the UWP platform.

In short, we have to do all the work ourselves!

Fortunately, there’s a few resources out there that I’ve compiled here to get you started. Let’s start with a simple example: authorizing an app to access a Google user account.

Google Samples for Windows and UWP

A good place to start is going to be on Github, where there is a collection of OAuth samples for Windows. These apps show you how to authenticate users in different Windows apps, including console apps, WPF, and UWP, which is what we’re interested in today.

The README for the UWP app describes the project in more detail, including how to get started, so I’ll leave it to the reader to check that out. Instead, I want to review a few important points about how this project is setup.

Create OAuth Credentials

Before getting started you want to make sure you have created OAUTH credentials for your application, as you’ll need a Client ID specifically setup for this authorization method for any of this to work.

The README for the sample specifies that you need to follow the instructions for the installed app specifically for iOS, as this works for UWP apps as well. So create your OAUTH key and note your Client ID which you’ll need to update in the sample.

Authorization Workflow

The way this sample was written is quite similar to the sample we looked at previously for authorizing a website to use a Google user account. Essentially, an authorization URL is constructed (using client id, and some other required parameters) and the user is redirected to that page via the browser.

This means the app will actually launch the browser on the device, taking the user out of the app to complete the login process.

So let’s take a look at the code that accomplishes this:

/// <summary>
        /// Starts an OAuth 2.0 Authorization Request.
        /// </summary>
        private void button_Click(object sender, RoutedEventArgs e)
        {
            // Generates state and PKCE values.
            string state = randomDataBase64url(32);
            string code_verifier = randomDataBase64url(32);
            string code_challenge = base64urlencodeNoPadding(sha256(code_verifier));
            const string code_challenge_method = "S256";

            // Stores the state and code_verifier values into local settings.
            // Member variables of this class may not be present when the app is resumed with the
            // authorization response, so LocalSettings can be used to persist any needed values.
            ApplicationDataContainer localSettings = ApplicationData.Current.LocalSettings;
            localSettings.Values["state"] = state;
            localSettings.Values["code_verifier"] = code_verifier;

            // Creates the OAuth 2.0 authorization request.
            string authorizationRequest = string.Format("{0}?response_type=code&scope=openid%20profile&redirect_uri={1}&client_id={2}&state={3}&code_challenge={4}&code_challenge_method={5}",
                authorizationEndpoint,
                System.Uri.EscapeDataString(redirectURI),
                clientID,
                state,
                code_challenge,
                code_challenge_method);

            output("Opening authorization request URI: " + authorizationRequest);

            // Opens the Authorization URI in the browser.
            var success = Windows.System.Launcher.LaunchUriAsync(new Uri(authorizationRequest));
        }

Although the process is similar to the web workflow we looked at for the MVC sample, we are using a slightly different URL and parameters to indicate that the request is coming from a device. For security reasons, we can’t embed our client secret in the app, because it could be sniffed over the wire when we POST it to exchange it for the access token.

Instead, the UWP sample leverages Proof Key Code Exchange (PKCE) to validate the request. Essentially, rather than sending the client secret, we hash a code in the app so that the server can know that the request came from us.

If you want to know more about this setup there’s a great description of the process on the Auth0 website: https://auth0.com/docs/api-auth/grant/authorization-code-pkce

Once the user completes the login, they are redirected to our app via the protocol activation defined in the manifest:

Launching the app registers this protocol on the device so that when the browser redirects the user to it the app is launched, passing along the OAUTH parameters so we can continue the login process.

In this case, launching the app again triggers the OnNavigatedTo event, which checks for the presence of a URI parameter, which is then parsed to validate the result so far:

/// <summary>
        /// Processes the OAuth 2.0 Authorization Response
        /// </summary>
        /// <param name="e"></param>
        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            if (e.Parameter is Uri)
            {
                // Gets URI from navigation parameters.
                Uri authorizationResponse = (Uri) e.Parameter;
                string queryString = authorizationResponse.Query;
                output("MainPage received authorizationResponse: " + authorizationResponse);

                // Parses URI params into a dictionary
                // ref: http://stackoverflow.com/a/11957114/72176
                Dictionary<string, string> queryStringParams =
                        queryString.Substring(1).Split('&')
                             .ToDictionary(c => c.Split('=')[0],
                                           c => Uri.UnescapeDataString(c.Split('=')[1]));

                if (queryStringParams.ContainsKey("error"))
                {
                    output(String.Format("OAuth authorization error: {0}.", queryStringParams["error"]));
                    return;
                }

                if (!queryStringParams.ContainsKey("code")
                    || !queryStringParams.ContainsKey("state"))
                {
                    output("Malformed authorization response. " + queryString);
                    return;
                }

                // Gets the Authorization code & state
                string code = queryStringParams["code"];
                string incoming_state = queryStringParams["state"];

                // Retrieves the expected 'state' value from local settings (saved when the request was made).
                ApplicationDataContainer localSettings = ApplicationData.Current.LocalSettings;
                string expected_state = (String) localSettings.Values["state"];

                // Compares the receieved state to the expected value, to ensure that
                // this app made the request which resulted in authorization
                if (incoming_state != expected_state)
                {
                    output(String.Format("Received request with invalid state ({0})", incoming_state));
                    return;
                }

                // Resets expected state value to avoid a replay attack.
                localSettings.Values["state"] = null;

                // Authorization Code is now ready to use!
                output(Environment.NewLine + "Authorization code: " + code);

                string code_verifier = (String) localSettings.Values["code_verifier"];
                performCodeExchangeAsync(code, code_verifier);
            }
            else
            {
                Debug.WriteLine(e.Parameter);
            }
        }

If everything checks out, we can finally exchange the resulting code for an access token, being sure to pass along the original code verifier so that the server can validate the request. Here is what that code looks like:

async void performCodeExchangeAsync(string code, string code_verifier)
        {
            // Builds the Token request
            string tokenRequestBody = string.Format("code={0}&redirect_uri={1}&client_id={2}&code_verifier={3}&scope=&grant_type=authorization_code",
                code,
                System.Uri.EscapeDataString(redirectURI),
                clientID,
                code_verifier
                );
            StringContent content = new StringContent(tokenRequestBody, Encoding.UTF8, "application/x-www-form-urlencoded");

            // Performs the authorization code exchange.
            HttpClientHandler handler = new HttpClientHandler();
            handler.AllowAutoRedirect = true;
            HttpClient client = new HttpClient(handler);

            output(Environment.NewLine + "Exchanging code for tokens...");
            HttpResponseMessage response = await client.PostAsync(tokenEndpoint, content);
            string responseString = await response.Content.ReadAsStringAsync();
            output(responseString);

            if (!response.IsSuccessStatusCode)
            {
                output("Authorization code exchange failed.");
                return;
            }

            // Sets the Authentication header of our HTTP client using the acquired access token.
            JsonObject tokens = JsonObject.Parse(responseString);
            string accessToken = tokens.GetNamedString("access_token");
            client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", accessToken);

            // Makes a call to the Userinfo endpoint, and prints the results.
            output("Making API Call to Userinfo...");
            HttpResponseMessage userinfoResponse = client.GetAsync(userInfoEndpoint).Result;
            string userinfoResponseContent = await userinfoResponse.Content.ReadAsStringAsync();
            output(userinfoResponseContent);
        }

As you can see at the end of that sample, we use the resulting access_token as a Bearer token to finally request the user information. Because there isn’t any helper libraries or SDK to wrap access to Google services, we have to do it ourselves once again via a simple HTTP REST call to the user endpoint which is defined in the app:

const string userInfoEndpoint = "https://www.googleapis.com/oauth2/v3/userinfo";

In the end, the result is the same, and we can now review the user’s profile information just like before, which the app outputs as text:

Although this works just fine, the authentication process demonstrated by the sample is obviously a bit cumbersome. Launching the browser and leaving the app is not an ideal experience for the user.

Fortunately, we can fix that by leveraging a helpful class from the .NET framework.

WebAuthenticationBroker

The WebAuthenticationBroker class exposes the static method AuthenticateAsync that accepts the same authorization URL that previously was launched by the browser. The difference here is that instead of leaving the app to authorize, it pops up an embedded browser so that you can complete the authorization from within the app itself.

A more complete description of this process is in the MSDN docs: Web authentication broker

For this to work, however, we do have to pass a URI that makes sense for the identity provider to redirect back to the app such that the broker can continue the process and hand the result back to the app.

While I began putting this together, I actually discovered that another developer LorenzCK has already created such an update, and has created a pull request to the Google sample that updates the sample to use this broker. Many thanks to the developer for sharing this code!

Replacing the MainPage.xaml.cs of the current sample with the updated code simplifies things quite a bit. Because we no longer leave the app to authenticate the user, we don’t need to save any of the generated values to local storage, and can handle the entire operation via the async authorize method of the broker.

private async void button_Click(object sender, RoutedEventArgs e)
        {
            // Generates state and PKCE values.
            string state = randomDataBase64url(32);
            string code_verifier = randomDataBase64url(32);
            string code_challenge = base64urlencodeNoPadding(sha256(code_verifier));
            const string code_challenge_method = "S256";

            // Creates the OAuth 2.0 authorization request.
            string authorizationRequest = string.Format("{0}?response_type=code&scope=openid%20profile&redirect_uri={1}&client_id={2}&state={3}&code_challenge={4}&code_challenge_method={5}",
                authorizationEndpoint,
                System.Uri.EscapeDataString(redirectURI),
                clientID,
                state,
                code_challenge,
                code_challenge_method);

            output("Opening authorization request URI: " + authorizationRequest);

            var result = await WebAuthenticationBroker.AuthenticateAsync(WebAuthenticationOptions.UseTitle, new Uri(authorizationRequest), new Uri(authorizationCompleteEndPoint));
            output("WebAuthenticationBroker result: " + result.ResponseStatus);
            switch (result.ResponseStatus)
            {
                case WebAuthenticationStatus.Success:
                    string data = result.ResponseData;
                    // Strip authentication result from data and process rest of encoded data.
                    ProcessAuthorization(data.Substring(data.IndexOf(' ') + 1), state, code_verifier);
                    break;

                case WebAuthenticationStatus.ErrorHttp:
                    output("HTTP error: " + result.ResponseErrorDetail);
                    break;

                case WebAuthenticationStatus.UserCancel:
                    break;
            }
        }

Once a successful result is returned from the operation, we can parse the result, validate like we did before, and exchange the code for an access token:

/// <summary>
        /// Processes the OAuth 2.0 Authorization Response
        /// </summary>
        /// <param name="data">Incoming data formatted as a query string</param>
        /// <param name="expected_state">Expected state value to verify that this app has initiated authentication</param>
        private void ProcessAuthorization(string data, string expected_state, string code_verifier)
        {
            output("MainPage received authorizationResponse: " + data);

            // Parses URI params into a dictionary
            // ref: http://stackoverflow.com/a/11957114/72176
            Dictionary<string, string> queryStringParams = data.Split('&').ToDictionary(
                c => c.Split('=')[0],
                c => Uri.UnescapeDataString(c.Split('=')[1])
            );

            if (queryStringParams.ContainsKey("error"))
            {
                output(String.Format("OAuth authorization error: {0}.", queryStringParams["error"]));
                return;
            }

            if (!queryStringParams.ContainsKey("code")
                || !queryStringParams.ContainsKey("state"))
            {
                output("Malformed authorization response. " + data);
                return;
            }

            // Gets the Authorization code & state
            string code = queryStringParams["code"];
            string incoming_state = queryStringParams["state"];

            // Compares the received state to the expected value, to ensure that
            // this app made the request which resulted in authorization
            if (incoming_state != expected_state)
            {
                output(String.Format("Received request with invalid state ({0})", incoming_state));
                return;
            }

            // Authorization Code is now ready to use!
            output(Environment.NewLine + "Authorization code: " + code);

            performCodeExchangeAsync(code, code_verifier);
        }

In addition, we no longer have to use the protocol activation, since we never leave the app, so this setting can be removed from the manifest as well. Instead, the return uri uses this format:

const string redirectURI = "urn:ietf:wg:oauth:2.0:oob:auto";

This tells Google to return the result to the title bar of the browser (in this case, the WebAuthenticationBroker). More information on the different options for redirect URI is here: https://developers.google.com/api-client-library/python/auth/installed-app#choosingredirecturi

Now when we run the app and click the button to login, the web broker launches inside the app, where we can safely provide our Google credentials and authorize it:

Authorizing the application closes the broker and processes the result just like before, showing the same user profile information in the app, all without ever leaving it!

Wrapping up and Next Steps

The Google Windows OAuth Samples are a great way to get started adding Google services to your Windows 10 apps by easily allowing users to authorize access to their accounts. Thanks to the efforts of LorenzCK we can take this a step further and leverage the frameworks WebAuthenticationBroker to simplify this process even further, resulting in a better experience for the user.

However, now that we’ve authorized a user account so we can access Google services, we need to be able to take it a step further, authorizing our own app to access our Google Cloud Platform services.

Fortunately, this is also possible, and will the subject of our next post. Until then as always, I hope this was helpful and thanks for reading!

The post Using Google Services in UWP C# Apps – Part 1 appeared first on Falafel Software Blog.

This is post 15 of 17 in the series “Google Cloud for the .NET Developer”

Caching is one of those solutions that is often added after you realize that there is a performance problem with your system. For example, fetching records from a database may be fast when you are developing locally as the only user. But, in production with hundreds or thousands of simultaneous requests taking place, that disk-based database will soon become a bottleneck. If the data is slowly changing, then there is really no need to hit the database itself after the first read: simply save the data to cache after fetching it, and read it out of cache instead on subsequent requests.

Redis is a popular open-source highly-scalable shared in-memory data store. You can think of it as a database of key/value pairs, like a NoSQL database, but it can also serve as a message queue and pub/sub server. And, while its normal operating mode is in-memory on one machine, there is also support for clustering and persistence to disk.

Redis is often implemented as part of a solution because it is:

• Cross-Platform: Being open source, a Redis server can run on both Windows and Linux operating systems. Even if your solution is based on .NET running on Windows Servers, the Redis server itself can be hosted on a lower-cost Linux instance.
• Cross-Server: Redis can run locally on the same machine as your application, but it is often installed as its own server in order to permit multiple machines to access it. In this way, the same data cache can be shared among servers.
• Cross-Application: A client API within your application is used to access the Redis server. One application can place data into Redis for another application to consume (like a message queue).
• Cross-Process: Even within the same application, Redis can be used as a means to decouple code that runs in different processes.

Installing Redis in the Google Cloud

Unlike features such as Cloud SQL (MySQL) or Cloud BigTable, Redis is not a first-class citizen in the Google Cloud Platform. So, you have to somehow install it as a Compute Engine instance.

One easy way to do this is to use the Cloud Launcher. Search for “redis”, and you will find both a Google-provided and a Bitnami-provided image:

The Google-curated image is configured as an advanced Redis cluster of 3 x n1-standard-4 instances with a 10GB boot disk running on Debian 8, and costs an estimated $400/month to run. The Bitnami-curated image is very simple out of the box, using a single f1-micro instance with a 10GB disk running on Debian 8, and costs an estimated $5/month.

For those who do not want to administer Redis themselves, another popular option is to use a subscription service to set up and manage Redis for you. Redis Labs, for example, provides Redis-as-a-service hosted on a number of popular cloud platforms (GCE included) for a reasonable price. It even includes a free tier that is sufficient for evaluation or even as the caching layer for small applications.

After creating a subscription, you must add the database(s) via the website:

Redis Labs will then take care of the rest, creating your image that you can immediately use from your application.

Once you are up and running, you can also access monitoring and statistics from the Redis Labs website.

Using Redis for Caching in your .NET Application

Search NuGet for “redis”, and you’ll find a lot of results. But, one in particular is the StackExchange.Redis client library with over 1.4 million downloads. This is a general-purpose Redis client that is built for performance, and supports all of the Redis Commands. If you have ever searched for help on StackOverflow, then you have been on the receiving end of StackExchange.Redis in action.

PM> Install-Package StackExchange.Redis

Let’s look at how to build our own simple Cache-Aside implementation using StackEchange.Redis. Cache-Aside is a design pattern that tries to read data from cache first. If the data is not there, then it will fetch the data from the database and save it to cache for subsequent reads.

Note: This sample is a complete Console application, but the interesting part of the Cache-Aside implementation is in the highlighted GetSpeakerById() method. To run this locally, be sure to install the StackExchange.Redis and Newtonsoft.Json NuGet packages, as well as substitute your own Redis server information.

using System;
using System.Threading.Tasks;
using StackExchange.Redis;

namespace dotnet_sample
{
    class Program
    {
        static void Main(string[] args)
        {
            var example = new Example();

            do
            {
                Console.Write("ID > ");
                var input = Console.ReadLine();

                if (input != "")
                {
                    int id = -1;
                    int.TryParse(input, out id);

                    var task = example.GetSpeakerById(id);
                    Task.WaitAll(task);

                    var speaker = task.Result;

                    Console.WriteLine("{0}: Timestamp = {1}", speaker.ID, speaker.TimeStamp);
                }
                else
                {
                    break;
                }
            }
            while (true);
        }

        class Example
        {
            private readonly ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("pub-redis-11750...com:11750,password=12345");

            public async Task<Speaker> GetSpeakerById(int id)
            {
                Speaker speaker = null;
                var key = $"speaker:{id}";

                var db = redis.GetDatabase();
                string data = await db.StringGetAsync(key);

                if (data != null)
                {
                    speaker = Newtonsoft.Json.JsonConvert.DeserializeObject<Speaker>(data);
                }

                if (speaker == null)
                {
                    speaker = await GetSpeakerByIdFromDb(id);

                    if (speaker != null)
                    {
                        data = Newtonsoft.Json.JsonConvert.SerializeObject(speaker);
                        await db.StringSetAsync(key, data, TimeSpan.FromSeconds(30));
                    }
                }

                return speaker;
            }

            private async Task<Speaker> GetSpeakerByIdFromDb(int id)
            {
                // Implement database call to retrieve speaker object...

                return new Speaker
                {
                    ID = id,
                    Name = "Jason Follas",
                    Bio = "Jason Follas is a Sr. Architect for Falafel Software and lives near Toledo, OH...",
                    Twitter = "@jfollas",
                    ImageUrl = "https://s.gravatar.com/avatar/f89789e4c3445d06ff7b5d97489d902d?s=80",
                    TimeStamp = DateTime.Now
                };
            }

        }

        class Speaker
        {
            public int ID { get; set; }
            public string Name { get; set; }
            public string Bio { get; set; }
            public string Twitter { get; set; }
            public string ImageUrl { get; set; }
            public DateTime TimeStamp { get; set; }
        }
    }
}

Some things to note in this code:

• The ConnectionMultiplexer is a long-lived object. Create it once and just keep it around for the life of your application.
• The method names are slightly different than the actual Redis commands. For example, Redis’s GET is called StringGet in this library.
• The library provides both synchronous and asynchronous versions of each command. For example: StringGet() and await StringGetAsync()
• Since Redis stores values as strings, the object graph is serialized to and from JSON in this code using the Newtonsoft.Json library.

The example app above sets the cache timeout to 30 seconds when the object is written to cache. After 30 seconds, the object is considered stale and will be removed. We can observe that the cached object is being used by watching the timestamp. Whenever it changes for a given ID, then we know that a “database fetch” has occurred:

ID > 1
1: Timestamp = 1/16/2017 4:57:48 PM

ID > 2
2: Timestamp = 1/16/2017 4:57:51 PM

ID > 1
1: Timestamp = 1/16/2017 4:57:48 PM

ID > 1
1: Timestamp = 1/16/2017 4:58:38 PM

ID >

You will need to decide what expiration is appropriate for your own application and data. Also, if an object is updated, it is common to remove it from cache at the same time as committing the changes to the database so that a fresh read is used on the next request.

Specialized Libraries

While the StackExchange.Redis library is a complete Redis client, using it directly might require more coding than you were hoping for. Fortunately, Redis is a very popular platform, and a number of specialized libraries have been written that use it as their backend for caching, session storage, message queueing, and a host of other things. In a lot of cases, these libraries actually use the StackExchange.Redis client themselves.

Here is a sampling of libraries and frameworks that can use Redis:

Hangfire.io: An easy way to perform background processing in .NET and .NET Core applications. No Windows Service or separate process required.

CacheManager: CacheManager is an open source caching framework for .NET written in C# and is available via NuGet. It supports various cache providers and implements many advanced features

CachingFramework.Redis: Distributed caching based on StackExchange.Redis and Redis. Includes support for tagging and is cluster-compatible.

Harbour.RedisSessionStateStore: Redis based SessionStateStoreProvider written in C# using ServiceStack.Redis

EFCache.Redis: Extends EFCache by adding Redis support

TagCache.Redis: .NET Redis Cache with support for tagging

RedisSessionProvider: Provides a drop-in class library that makes ASP.NET’s System.Web Session object store its contents in a Redis server or servers.

ServiceStack: Thoughtfully architected, obscenely fast, thoroughly enjoyable web services for all. Note: Commercial product, developer licensing required

The post Redis Caching in the Google Cloud Platform appeared first on Falafel Software Blog.

This is post 14 of 17 in the series “Google Cloud for the .NET Developer”

If you are a .NET developer and have been following this series, you may have read the previous section covering Google Cloud Platform’s Cloud SQL as part of the Cloud Storage Options. In that example, I showed how to create and connect to a Cloud SQL instance database using Visual Studio’s Server Explorer. But there’s more to that story! I also want to show how to take that connection and use our Cloud SQL database with Entity Framework in a sample Web application.

Before we create the Entity Framework model, we should add some tables to test with. At this point you can use ANY interface you like to execute the following commands, but my favorite ad-hoc query execution environment is LINQPad! It’s free and I wanted to see how it works with a Cloud SQL instance. Just for the sake of completeness, I’ll show you how to connect LINQPad to the Cloud SQL instance.

First Steps

Before you start, review the previous post and create your Cloud SQL instance, either using your gcloud shell or the GCP Console.

LINQPad Connection

Before you can connect to LINQPad, you’ll have to add a MySQL driver. If you don’t see a driver in the list that supports MySQL, you can use the “View more drivers” option to install the IQ driver.

Then, create the connection using the IP address of your Cloud SQL instance and the root user password.

Once the connection succeeds, you can create a Query. Among the reasons I love LINQpad is the ability to write queries in C#, but in this case you can choose SQL for the language.

Now execute the following SQL to create a table of survey questions, with a foreign key to a table of question types.

CREATE TABLE IF NOT EXISTS questiontype (
  questiontypeID  int unsigned  NOT NULL AUTO_INCREMENT,
  name  varchar(30)  NOT NULL DEFAULT '',
  PRIMARY KEY (`questiontypeID`)
);

CREATE TABLE IF NOT EXISTS surveyquestion (
  surveyquestionID    int unsigned  NOT NULL AUTO_INCREMENT,
  surveyquestiontext         varchar(255)       NOT NULL DEFAULT '',
  questiontypeID    int unsigned  NOT NULL,
  PRIMARY KEY (surveyquestionID),
  FOREIGN KEY (questiontypeID) REFERENCES questiontype (questiontypeID)
);

INSERT INTO questiontype (name) VALUES
 ('yesno'),
 ('starrating'),
 ('shortanswer')
;

INSERT INTO surveyquestion (surveyquestiontext, questiontypeID) VALUES
  ('Would you purchase this product again?', 1),
  ('How would you rate the quality of our product?', 2),
  ('How would you rate the price of our product?', 2),
  ('Do you have any comments to add?', 3)
;

You should now be able to expand the Tables view in LINQpad and see our sample schema.

Add an Entity Framework model

To demonstrate an Entity Framework model created from this Cloud SQL database, we can use an empty WebAPI web application project, which you can download here.

Note: you’ll need to add some MySQL nuget packages if you are creating this project on your own.

Creating the model is very straightforward. Start by adding the ADO.NET model object using the wizard.

And if you have the packages above, you will be able to create the EF Designer model and connect to the Cloud SQL instance just as we did before.

Save the connection and choose to add our tables to the model.

Now we can see our tables in the model, and see that a navigation property has been added to let us navigate from questions to question types.

Great! At this point be sure to build the application. Next, let’s use that model in a very simple test API call.

Add a controller called SurveyQuestionsController.

And in the controller Get method, add the following code which uses the new Entity Framework model classes.

public class SurveyQuestionsController : ApiController
    {
        // GET api/<controller>
        public HttpResponseMessage Get()
        {
            using (var db = new falafelefdemoEntities())
            {
              var questions = db.surveyquestions.Select(q =>
                   new
                   {
                       Text = q.surveyquestiontext,
                       TypeName = q.questiontype.name
                   }).ToList();
                return Request.CreateResponse(HttpStatusCode.OK, questions);
            }
        }

    }

If you run the application now, you can test this API call by browsing (or using Postman, if you prefer) to the host address + /api/surveyquestions. The response should include the questions plus the names of their question types, which was assembled using our Entity Framework navigation property.

And there you have it! A working Entity Framework model, from Visual Studio, all using Google Cloud Platform’s Cloud SQL instance.

The post Entity Framework with Google Cloud SQL appeared first on Falafel Software Blog.

This is post 13 of 17 in the series “Google Cloud for the .NET Developer”

NoSQL

Cloud Datastore

.NET Datastore API

Using the Console

 

 

 

Example in C#

// dsdb = DatastoreDb.Create(projectId, dsNamespace);
var kFactory = dsdb.CreateKeyFactory("SurveyQuestion");
var entities = new List<Entity>()
{
    new Entity()
    {
        Key = kFactory.CreateIncompleteKey(),
        ["questiontype"] = "yesno",
        ["text"] = "Would you purchase this product again?",
        ["categories"] = new ArrayValue() {Values = {"product", "purchase"}},
    },
    new Entity()
    {
        Key = kFactory.CreateIncompleteKey(),
        ["questiontype"] = "starrating",
        ["text"] = "How would you rate the quality of our product?",
        ["categories"] = new ArrayValue() {Values = {"product", "quality"}},
    },
    new Entity()
    {
        Key = kFactory.CreateIncompleteKey(),
        ["questiontype"] = "starrating",
        ["text"] = "How would you rate the price of our product?",
        ["categories"] = new ArrayValue() {Values = {"product", "price"}},
    }
};

dsdb.Upsert(entities);

Query query = new Query("SurveyQuestion")
{
    Filter = Filter.Equal("categories", category)
};

var results = dsdb.RunQuery(query).Entities;

Cloud Bigtable

.NET Compatibility

The post Cloud Storage Options Part 2 appeared first on Falafel Software Blog.

This is post 12 of 17 in the series “Google Cloud for the .NET Developer”

Storage Options

First Steps

Structured vs Unstructured

Google Cloud Storage

 

gsutil mb -p [yourprojectname] -c multi_regional gs://[youruniquebucketname]

Credentials

gcloud beta auth application-default login

StorageClient storageClient = StorageClient.Create();
if (storageClient.ListBuckets(projectId).All(b => b.Name != bucketName))
{
   // Creates the new bucket
   storageClient.CreateBucket(projectId, bucketName);
   Console.WriteLine($"Created new bucket {bucketName}");
   return;
}
Console.WriteLine($"Bucket {bucketName} found");

StorageClient storageClient = StorageClient.Create();
using (var f = File.OpenRead(filepath))
{
   var objectName = Path.GetFileName(filepath);
   storageClient.UploadObject(bucket, objectName, null, f);
   Console.WriteLine($"{objectName} uploaded to bucket {bucket}");
}

Google Cloud SQL

Google Cloud SQL is our first structured Cloud storage option. This is your full-featured MySQL database service, for relational data in the cloud, managed by Google. If you come from a .NET background and aren’t familiar with MySQL, you may want to read up on it to get started https://cloud.google.com/sql/. MySQL is the most popular open-source, cross-platform relational database, and it is the relational-data storage mechanism of choice for Google itself, as well as well-known heavy hitters like Facebook and Adobe. If you are “all-in” with Google Cloud, take a good look at MySQL, because you will probably find the most experience, documentation, and integrations with the rest of Google Cloud start with Google Cloud SQL.

To create a Cloud SQL Instance, navigate to the SQL option in the GCP Console and choose Create instance.

    

 I’m selecting the Second Generation option.

You can add a name and leave the default selections, then choose Create. Or, you can use this gcloud command:

gcloud beta sql instances create instance1 --tier=db-n1-standard-8 --activation-policy=ALWAYS

Using either method, you should now be able to see the new instance in the Console.

 

Keeping with our .NET theme, I’ll also show you how to connect to the new Google Cloud SQL instance using Visual Studio.

First Steps

Here’s what you’ll need:

MySQL ODBC connector

Cloud Tools for Visual Studio , authenticated and connected to the same project as the Cloud SQL instance

MySQL tools for Visual Studio

Using the Cloud Tools Google Cloud Explorer, you should be able to see the instance under the Google Cloud SQL heading.

But before we can connect, we need to allow connections from our development machine. The following gcloud commands will add a single IP address to the authorized networks list (use your local IP to connect from your local machine), and set the root user’s password, where instance1 is the Cloud SQL instance name.

gcloud sql instances set-root-password instance1 --password=[newpassword]
gcloud sql instances patch instance1 --authorized-networks=[myipaddress]

You can learn more about the patch and other instance commands here.

Once your IP address is allowed, you can use the root user and the password you just created to add a connection in Visual Studio, just as you would for any other database.

Now you will see the instance inside Visual Studio’s Server Explorer. Just to show that we can – let’s add a table with an int column, by right clicking and creating a new query with the text

create table testtable1 (col int)

Other Resources

The post Cloud Storage Options Part 1 appeared first on Falafel Software Blog.

This is post 11 of 17 in the series “Google Cloud for the .NET Developer”

If you are planning to or even considering jumping in to Google Cloud Platform and you work with .NET technologies, you’ll almost certainly want to know how to run SQL Server in the Google Cloud. Google Cloud has made a big effort lately to more fully support the .NET stack, including SQL Server. This is good news for everyone, because more options means more chances to find the right fit for your development project!

Why Run SQL Server in the Google Cloud?

There could be multiple answers to this question, but here are a couple to consider: If you are maintaining or migrating a production solution, you might be looking to take advantage of other services in the Google Cloud Platform. And you may already have a SQL server instance or instances as a part of your stack.

In that case, you’ll have to consider your current deployment strategy against the GCP offerings. Knowing that you CAN run SQL Server on Google Cloud is a good start! You will also want to consider licensing – if you are already running on another cloud platform you are probably already familiar with how that works, particularly if you already use Microsoft License Mobility.

Note that there are different pricing levels for SQL Server Express, Standard, and Web, and that currently Enterprise is “Coming Soon”. What’s interesting and might be a game changer for some customers, is that using SQL Server on Google Cloud lets you pay-as-you-go for SQL Server licensing, just as you do for other cloud resources. So take a look at regular licensing fees for SQL server and you’ll see why that might be a good choice!

But the case I want to consider first is a little more developer-centered. How would a .NET developer who is just getting started with Google Cloud Platform go about setting up a simple SQL Server instance on a VM and connect to it? This is a great exercise in taking something you probably already know – how to set up and connect to a SQL Server instance for development, except do it on GCP.

Before You Start

Before you get started, there are a couple of pieces you need to have ready:

• SQL Server Management Studio installed on an accessible machine. Since we will be testing with SQL Server 2016, you can download SSMS for free here
• A Google Cloud account – just sign up and get 60 days and $300 in credits right away 
• A GCP Project already created to house our instance  – learn more about Projects in Google Cloud here

Creating the SQL Server Instance

From the Console, choose VM Instances and Create Instance.



Now we must choose options for our VM. If you’re familiar with this process in Azure, you may want a reference to the recommended machine configurations for SQL Server.

To get something comparable to the most economical option from the Azure recommendations (DS12_V2), let’s choose the n1-highmem-4 configuration for Google Cloud.

Next, set the boot disk to an image with SQL Server pre-installed. Choose Change on the Boot Disk section, and then select the Application images tab in the Boot disk menu.

Now you can select the SQL Server image of your choice. We can leave the other options as-is and click Create. Once the instance is created (which you’ll notice is lightning fast!), you can select the new VM in your instances list.

Then choose Create or reset Windows password. Make SURE to note the account name and password somewhere safe, you will need them to access this VM. But if you misplace them, this is also how you can reset the Windows password.

Connect to the VM

Now we can remotely connect to the VM. Click the RDP button on the instance page. If you haven’t already, this is a good time to install the Chrome RDP Extension! You can also download the RDP file to connect using the Windows client.

Now you can enter the credentials you created for the Windows account. Then you should be able to see the server manager for your new Windows Server VM, and verify that SQL Server is running.

Configuring for a Development Connection

At this point, if you want to alter any of the SQL Server features, you can access the SQL Server installer directly on the VM. You can also open SSMS. Here I just typed SQL into the windows search to bring up these two options. They are both available by default, just because we chose the SQL Server image for our VM.

Open SSMS and use the preset windows authentication login. Now we can change settings directly on our SQL Server instance, just as we would using SSMS locally. For the rest of our example, we are going to set up this SQL server instance as if we wanted to connect from our local machine for development. This isn’t necessarily something you would need for production, but instead lets us see how to make familiar changes to SQL Server even when running on Google Cloud. If we want to enable the sa account for development purposes, we will need to enable SQL Server authentication by selecting properties and then the security tab.

Then turn on SQL Server and Windows Authentication mode.

We also have to expand the Logins folder and select sa >properties to set a password. Under Status, select Enabled to turn the account on. It is a good idea to restart after this step and test the login.

Enable External Access to SQL Server

If we want to access this SQL server instance from outside the VM, we have to add a firewall rule.  The default SQL Server installation included in the image is already set up from the VM side, so we just need to allow connections via the networking configuration. Under Compute > Networking from the Console menu, we can see the current firewall rules and also add a new one to allow connections to port 1433 for SQL Server.

You can set the firewall rule to be as open or restrictive as you like – “allow from any source” will work for any IP, you can add a range, or simply your development machine’s IP. To add a single IP choose the option for IP ranges – single values are also allowed, and no subnet mask is required.

We’re almost there! To connect from a local SSMS, you’ll need the external IP of the VM. Go to External IP Addresses in the console and copy that address.

Finally, use that IP and your SQL Server Authentication credentials to connect from your local machine. Now you can use that connection to set up connection strings in your web.config files or anywhere you would normally use SQL credentials in your development process.

More Resources

Google has some great related tutorials that you may also want to check out:
Creating a High-Performance SQL Server Instance 
Best Practices for SQL Server Instances
SQL Server images on Google Computer Engine

The post SQL Server in the Google Cloud appeared first on Falafel Software Blog.

This is post 10 of 17 in the series “Google Cloud for the .NET Developer”

Getting Started

Creating a Pub/Sub Topic

 

Next you will need to create a service account to authenticate to Pub/Sub with. Please review this <LINK>post</LINK> for instructions on how to do so. The service account will require the Pub/Sub Editor role, as we will be creating a subscription to our topic. Be sure to make a copy of the credential helper class located at the bottom of the post for our use in this example. The scope we will be authenticating to will be https://www.googleapis.com/auth/pubsub .

Pub/Sub Topic Subscriptions

GCP Pub/Sub

The Pub/Sub Message

Pull Subscription Helper Class

using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

namespace FalafelDev
{

    public class GCP_OAuth_Restful_Pull_PubSub<T> 
    {
        private string _rootUrl = "https://pubsub.googleapis.com";
        private string _projectName;
        private string _topicName;
        private string _subscriptionName;
        private GCP_OAuth_ServiceCredential _credential;     
  
        public GCP_OAuth_Restful_Pull_PubSub(GCP_OAuth_ServiceCredential credential, string projectName, 
                   string topicName, string desiredSubscriptionName="")
        {
            this._credential = credential;
            this._projectName = projectName;
            this._topicName = $"projects/{projectName}/topics/{topicName}";
            this._subscriptionName = $"projects/{projectName}/subscriptions/{desiredSubscriptionName}";            
        }

        /// <summary>
        /// Obtains Auth0 token and creates subscription queue if needed
        /// </summary>
        /// <returns>true if successful</returns>
        public async Task<bool> Initialize()
        {
            return await _createSubscription();
        }

        public async Task<List<string>> PublishMessage(T data)
        { 
            //topic format -> projects/csharppubsub/topics/demoData 
            string endpoint = _rootUrl + $"/v1/{_topicName}:publish";

            PubSubMessage psm = new PubSubMessage();
            psm.Attributes = data;
            //psm.Data ="Hello World".EncodeBase64(); <-- optionally include b64 encoded message

            PublishMessageRequest message = new PublishMessageRequest();
            message.Messages = new List<PubSubMessage> { psm };

            string json = JsonConvert.SerializeObject(message, 
                new JsonSerializerSettings { ContractResolver = 
                new CamelCasePropertyNamesContractResolver() });

            StringContent content = new StringContent(json);
            var httpClient = await _credential.GetHttpClient();
            if (httpClient != null)
            {
                var response = await httpClient.PostAsync(endpoint, content);
                string jsonResult = await response.Content.ReadAsStringAsync();
                var result = JsonConvert.DeserializeObject<PublishMessageResponse>(jsonResult);
                if (result == null || result.MessageIds == null || result.MessageIds.Count == 0)
                {
                    return new List<string>();
                }
                else
                {
                    return result.MessageIds;
                }
            }
            return null;
        }

        public async Task<List<T>> PullMessages(int maxMessages)
        {
            string endpoint = _rootUrl + $"/v1/{_subscriptionName}:pull";

            PullSubscriptionRequest message = new PullSubscriptionRequest();
            message.ReturnImmediately = true;
            message.MaxMessages = maxMessages;

            string json = JsonConvert.SerializeObject(message, 
                new JsonSerializerSettings { ContractResolver = 
                new CamelCasePropertyNamesContractResolver() });

            StringContent content = new StringContent(json);
            var httpClient = await _credential.GetHttpClient();
            if(httpClient != null)
            {
                var response = await httpClient.PostAsync(endpoint, content);
                string jsonResult = await response.Content.ReadAsStringAsync();
                var result = JsonConvert.DeserializeObject<PullSubscriptionResponse>(jsonResult);
                if(result == null || result.ReceivedMessages==null || result.ReceivedMessages.Count == 0)
                {
                    return new List<T>();
                }
                else
                {
                    List<string> ackIds = result.ReceivedMessages.Select(x => x.AckId).ToList();
                    var retValue = result.ReceivedMessages.Select(x => x.Message.Attributes).ToList();
                    
                    /* var strings = result.ReceivedMessages.Select(x => x.Message.Data.DecodeBase64())
                               .ToList(); <-- optional retrieve b64 encrypted message */

                    await _acknowledgeMessages(ackIds);
                    return retValue;
                }
            }
            return null;
        }

        private async Task<bool> _acknowledgeMessages(List<string> ackIds)
        {
            string endpoint = _rootUrl + $"/v1/{_subscriptionName}:acknowledge";

            AcknowledgeMessageRequest message = new AcknowledgeMessageRequest();
            message.AckIds = ackIds;

            string json = JsonConvert.SerializeObject(message, 
                new JsonSerializerSettings { ContractResolver = 
                new CamelCasePropertyNamesContractResolver() });

            StringContent content = new StringContent(json);
            var httpClient = await _credential.GetHttpClient();
            if (httpClient != null)
            {
                var response = await httpClient.PostAsync(endpoint, content);
                if (response.StatusCode == HttpStatusCode.OK)
                {
                    return true;
                }
            }
            return false;
        }

        private async Task<bool> _createSubscription()
        {
            //subscription name format projects/csharppubsub/subscriptions/CSHARP
            var endpoint = _rootUrl + $"/v1/{_subscriptionName}";

            CreateSubscriptionRequest message = new CreateSubscriptionRequest();
            message.Topic = _topicName;
            message.AckDeadlineSeconds = 60;

            string json = JsonConvert.SerializeObject(message,
                new JsonSerializerSettings { ContractResolver = 
                new CamelCasePropertyNamesContractResolver() });

            StringContent content = new StringContent(json);
            var httpClient = await _credential.GetHttpClient();
            if (httpClient != null)
            {
                var response = await httpClient.PutAsync(endpoint, content);
                //conflict is returned if subscription already exists
                if(response.StatusCode== HttpStatusCode.OK || 
                    response.StatusCode == HttpStatusCode.Conflict)
                {
                    return true;
                }
            }
            return false;
        }

 
        /* Google Cloud Platform Pub/Sub REST Api Models for Deserialization */
        internal class PubSubMessage
        {
            //base64 encoded
            public string Data { get; set; }
            public T Attributes { get; set; }
            public string MessageId { get; set; }
            public DateTime? PublishTime { get; set; }
        }

        internal class CreateSubscriptionRequest
        {
            public string Topic { get; set; }
            public object PushConfig = null;
            public int AckDeadlineSeconds { get; set; }

        }

        internal class PullSubscriptionRequest
        {
            public bool ReturnImmediately { get; set; }
            public int MaxMessages { get; set; }
        }

        internal class PullSubscriptionResponse
        {
            public List<ReceivedMessage> ReceivedMessages { get; set; }
        }

        internal class PublishMessageRequest
        {
            public List<PubSubMessage> Messages { get; set; }
        }

        internal class PublishMessageResponse
        {
            public List<string> MessageIds { get; set; }
        }

        internal class ReceivedMessage
        {
            public string AckId { get; set; }
            public PubSubMessage Message { get; set; }
        }

        internal class AcknowledgeMessageRequest
        {
            public List<string> AckIds { get; set; }
        }
        
    }
}

public class MyObject
{
    public string MyName { get; set; }
    public string MyChild { get; set; }
}

private static async Task GoogleCloudPullPubSub()
{
    string serviceAccountEmail = "pubsubsvcacct-cert@csharppubsub.iam.gserviceaccount.com";
    string p12CertificatePath = "CSharpPubSub-37ef513cf864.p12";
    string projectName = "csharppubsub";
    string topicName = "demoData";
    string subscriptionName = "CSHARP";

    GCP_OAuth_ServiceCredential credential = new GCP_OAuth_ServiceCredential(serviceAccountEmail, 
        p12CertificatePath, new List<string> { "https://www.googleapis.com/auth/pubsub" });
    GCP_OAuth_Restful_Pull_PubSub<MyObject> pubsub = new GCP_OAuth_Restful_Pull_PubSub<MyObject>(credential, 
        projectName, topicName, subscriptionName);

    //initialize when ready to start interacting with the GCP Topic
    bool isInitialized = await pubsub.Initialize();
    if (isInitialized)
    {
        var messageIds = await pubsub.PublishMessage(
            new MyObject { MyName = "Carey", MyChild = "Hunter" });
        var myObjects = await pubsub.PullMessages(100);

        foreach(var obj in myObjects)
        {
            Console.WriteLine($"My Name: {obj.MyName}, My Child: {obj.MyChild}");
        }
    }
}

GoogleCloudPullPubSub().Wait();
Console.WriteLine("FINISHED");
Console.ReadLine();

Restful Pub/Sub Console

The post Pub/Sub Part 2 : REST-based Google Cloud Pub/Sub with OAuth and C# appeared first on Falafel Software Blog.

This is post 9 of 17 in the series “Google Cloud for the .NET Developer”

Google Cloud Platform IAM & Admin

Google Cloud Platform Create Service Account

Google Cloud Platform Service Account Creation Form

New Visual Studio Project

Adding the Google.Apis.Auth NuGet Package

Including the Service Account P12 Key in Visual Studio

Google Authentication Scopes for Pub/Sub

using Google.Apis.Auth.OAuth2;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography.X509Certificates;
using System.Threading;
using System.Threading.Tasks;

Console.WriteLine("Google Cloud Service Account using OAuth Example");

string p12CertificatePath = "CSharpPubSub-c07c67be2080.p12";
string serviceAccountEmail = "oauth-to-gcp-sample@csharppubsub.iam.gserviceaccount.com";
var certificate = new X509Certificate2(p12CertificatePath, "notasecret", X509KeyStorageFlags.Exportable);

var credential = new ServiceAccountCredential(
        new ServiceAccountCredential.Initializer(serviceAccountEmail)
        {
            Scopes = new[] { "https://www.googleapis.com/auth/pubsub" }
        }.FromCertificate(certificate));

credential.RequestAccessTokenAsync(CancellationToken.None).Wait();

Console.WriteLine($"OAuth Token Obtained: {credential.Token.AccessToken}");
Console.WriteLine($"Is OAuth Token Expired ?: {credential.Token.IsExpired(credential.Clock)}");

Console.ReadLine();

Getting an OAuth Token from Google

Now that we have an OAuth token, we have the ability to call into Pub/Sub related API calls (defined by our scope(s)). Use this token as a Bearer token in the Authorization header of your http calls, as shown below:

var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", credential.Token.AccessToken);

using Google.Apis.Auth.OAuth2;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography.X509Certificates;
using System.Threading;
using System.Threading.Tasks;

namespace FalafelDev
{
    public class GCP_OAuth_ServiceCredential
    {
        public ServiceCredential Credential { get; }

        public GCP_OAuth_ServiceCredential(string serviceAccountEmail, string p12CertificatePath, List<string> scopes)
        {
            var certificate = new X509Certificate2(p12CertificatePath, "notasecret", X509KeyStorageFlags.Exportable);
            Credential = new ServiceAccountCredential(
                 new ServiceAccountCredential.Initializer(serviceAccountEmail)
                 {
                     Scopes = scopes 
                 }.FromCertificate(certificate));
        }

        public async Task<HttpClient> GetHttpClient()
        {
            bool hasToken = false;

            if (Credential.Token == null || Credential.Token.IsExpired(Credential.Clock))
            {
                hasToken = await Credential.RequestAccessTokenAsync(CancellationToken.None);
            }
            else
            {
                hasToken = true;
            }
            if (hasToken)
            {
                var httpClient = new HttpClient();
                httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", 
                       Credential.Token.AccessToken);
                httpClient.DefaultRequestHeaders.Accept.Clear();
                httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                return httpClient;
            }

            return null;

        }
    }
}

The post Pub/Sub Part 1 : C# OAuth Authentication to Google Cloud Pub/Sub using a Service Account appeared first on Falafel Software Blog.

This is post 8 of 17 in the series “Google Cloud for the .NET Developer”

Isaac Asimov speculated that you could plug a politician’s speech into a mathematical model, zero out the equation, and prove that the politician had said nothing. We know this intuitively, but I never thought you could actually do it. The Natural Language API from the Google Cloud Platform comes close by measuring sentiment found in text. The Natural Language API sentiment score ranges from –1.0 (negative emotion) to 1.0 (positive emotion). Ever watch HGTV? This may sound familiar:

“The kitchen is so cramped. I really detest the backsplash and I absolutely hate the cabinets. I’ve never seen such a poor excuse for a kitchen.”

Emphatically negative. They’ll have to rip out everything out of their first world kitchen and start over. The flip side is equally strong, but positive:

“The kitchen is the best ever! The spacious layout is perfect and has everything for our needs.”

We’ll take a look at the three major features of the Natural Language API: sentiment analysis to measure feeling and intent, entity analysis to identify people/places/things mentioned in the text, and syntactic analysis to describe the underlying linguistic structure of the text.

Sentiment Analysis

We’ll get to the code in a sec, but first try it here.

The scores for each sentence are clearly negative. The magnitude, measured from 0.0 to infinity, indicates strength of feeling. Now once more (with feeling), take a look at this strong positive statement:

The API returns score and magnitude for each sentence and for the entire document. Each magnitude contributes to the document, so longer documents can reach higher magnitudes.

As with many of the Google Cloud API’s, you can hit the API directly from a REST service or use a C# wrapper. In these examples, I’m using Google.Cloud.Language.V1 package from NuGet to install the C# wrappers. Once installed, you can use the Google.Cloud.Language.V1 namespace and its LanguageServiceClient class to access key methods.

The general pattern is to create a LanguageServiceClient, create a Document object for the text, and then call one of the LanguageServiceClient methods: AnalyzeSentiment(), AnalyzeEntities() or AnalyzeSyntax(). Client methods each return a response object. For example, AnalyzeSentiment returns a Sentences collection in the response. Each sentence has text content, score and magnitude.

var response = client.AnalyzeSentiment(doc);

foreach (var sentence in response.Sentences)
{
    Console.WriteLine(columns,
        sentence.Text.Content,
        sentence.Sentiment.Score,
        sentence.Sentiment.Magnitude);
}

Note: You can assign text to the Document Content property directly, or assign the GcsContentUri property to point at storage on the cloud. The Document class lives in the Google.Cloud.Language.V1 namespace.

using Google.Cloud.Language.V1;

const string columns = "{0,-30}{1,10}{2,10}";

var client = LanguageServiceClient.Create();

var doc = new Document()
{
    Content = "The kitchen is the best ever! The layout is perfect.",
    Type = Document.Types.Type.PlainText
};

var response = client.AnalyzeSentiment(doc);

Console.WriteLine(columns, "", "Score", "Magnitude");


foreach (var sentence in response.Sentences)
{
    Console.WriteLine(columns,
        sentence.Text.Content,
        sentence.Sentiment.Score,
        sentence.Sentiment.Magnitude
        );
}

Console.WriteLine(columns,
    "Document Sentiment",
    response.DocumentSentiment.Score,
    response.DocumentSentiment.Magnitude);

}

The output shows the score and magnitude for each sentence and for the document as a whole.

Caveat: The API was just released in July 2016, so its early days yet. Sentiment analysis is still vulnerable to misunderstanding, particularly for small amounts of text. “I’d really hate to lose the kitchen” scores a -3 sentiment while “I’d really love to lose the kitchen” is a +4. But the API isn’t a special purpose one-off. It’s an outgrowth of Google’s Machine Learning product, so my expectation is that accuracy will improve.

Entities

AnalyzeEntities() identifies key objects in text: their importance (salience) and their types (e.g. person, organization, location, event…) Each instance of an entity is a Mention that includes its position in the text. The text example is a little longer and has repeated mentions of “Google” and “California”.

Here’s the output shown in descending order by salience. This example only lists the entities, but you can rummage through the mentions for each entity as well.

Syntax Analysis

To tease meaning from a document, such as sentiment or entities, there’s grunt work to be done first — extracting sentences and words, labeling parts of speech, and mapping relationships between words. AnalyzeSyntax does this fundamental work for you by examining a document and reporting its linguistic makeup.

AnalyzeSyntax extracts an array of Token where tokens are the words and punctuation that make up a sentence. Each Token has a TextSpan with its text content and position, PartOfSpeech to describe its function in the sentence, DependencyEdge to map the token’s relationship with other tokens, and lemma. The lemma is a base word that other words are formed from, for example “run” is the lemma for “running” and “ran”.

The PartOfSpeech Types defines a token’s role in terms of case, gender, mood, tense and so on.

Here’s an example that slices-and-dices the phrase “It was the best of times, it was the worst of times”. Reflection + Linq list the parts of speech in a text description. Any parts of speech with the value Unknown are left out.

// create the Document object
// Document is defined in the Google.Cloud.Language.V1 namespace
var doc = new Document()
{
    Content = "It was the best of times, it was the worst of times",
    Type = Document.Types.Type.PlainText
};

// create a client with default settings            
var client = LanguageServiceClient.Create();

// analyze syntax in the doc 
var response = client.AnalyzeSyntax(doc);

// list tokens
var tokens =
    from t in response.Tokens
    let partsOfSpeech = from prop in t.PartOfSpeech
    .GetType()
    .GetProperties(BindingFlags.Public | BindingFlags.Instance)
                        where !prop.GetValue(t.PartOfSpeech).ToString().Equals("Unknown")
                        select prop.Name + "(" + prop.GetValue(t.PartOfSpeech) + ")"
    select new
    {
        Offset = t.Text.BeginOffset.ToString(),
        Text = t.Text.Content,
        Description = string.Join(", ", partsOfSpeech)
    };

// print the list of tokens and descriptions
tokens.ToList().ForEach((token) =>
{
    Console.WriteLine("{0,6} {1, 10} {2,-30}", token.Offset, token.Text, token.Description);
});

Here’s the output in the console window:

Where to from here?

I’m intrigued by the possibilities of the API, all on its own. But there’s a natural affinity with related API’s — BigQuery, Speech, Vision Optical Character Recognition, and Translation – that could generate some really interesting mashups. For example, analyzing top news trends, scanning help desk email for trouble spots, or gauging reaction to social media (without using a star rating UI). I suppose the API could be used to react in real-time to text as its produced, but the real value may be in getting actionable data from the large chunks of unstructured text data found on servers all over the world.

The post Understanding Natural Language appeared first on Falafel Software Blog.

Maintaining a web.config in your ASP.NET application can quickly get out of hand. It contains the bulk of your web application’s settings and configurations, and even the fresh, out-of-the-box version is several hundred lines long. If you have a set of IIS URL Rewrite Rules to maintain in the same file, the web.config can become immense. This is where using configsource can come in handy.

Benefits of ConfigSource

In my view there are some large advantages to separating your list of rewrite rules out from the web.config file into a separate, configsource-appointed config file. The first is the above-mentioned maintainability of the web.config. Rather than letting the web.config grow in size, doubling depending on the complexity of your rewrite rules, you only add a few lines one time (the configsource instruction) and never have to delve into the web.config again.

The second major advantage is that you no longer have to concern yourself with restarting your web application just because you wish to update a rewrite rule. By default. ASP.NET web applications watch certain files and folders for any changes, and trigger an automatic restart if any of them are touched. The web.config file is one such file. When you have your rewrite rules as a configsource entry instead of being inlined within the web.config, you can change the rules as much as you like without having to restart your application one or more times. And if you do want to restart, you’re still free to do so anyway. But the choice is now in your hands.

Separation of concerns is another plus to using configsource. The web.config file has a lot of responsibilities and reasons to change as it is (major no-nos when trying to adhere to SOLID principles. With configsource, you can have a file whose sole responsibility and reason to change is to maintain IIS rewrite rules, and the web.config can happily pass that responsibility along to the latter.

Enabling ConfigSource for Rewrite Rules in your Web.Config

Setting up your web.config to have rewrite rules using configsource is incredibly simple. Take this segment of a web.config that has some rewrite rules in it:

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
  <!-- Snip -->
  <system.webServer>
    <!-- Snip -->
    <rewrite>
      <rules>
        <rule name="RemoveTrailingSlashRule1" enabled="false" stopProcessing="true">
          <match url="(.*)/$" />
          <conditions logicalGrouping="MatchAll" trackAllCaptures="false">
            <add input="{REQUEST_FILENAME}" matchType="IsDirectory" negate="true" />
            <add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />
            <add input="{REQUEST_FILENAME}" pattern="(.*?)\.svc$" negate="true" />
          </conditions>
          <action type="Redirect" url="{R:1}" />
        </rule>
        <rule name="LowerCaseRule1" enabled="false" stopProcessing="true">
          <match url="[A-Z]" ignoreCase="false" />
            <action type="Redirect" url="{ToLower:{URL}}" redirectType="Permanent" />
        </rule>
      </rules>
    </rewrite>
  </system.webServer>
  <!-- Snip -->
</configuration>

To separate your rules out, leave the XML within , but remove all of its contents and make it a self-closing tag. Add a “configSource” sttribute and specify the name of the file where your rules will live going forward.

<rewrite>
  <rules configSource="rewrite.config" />
</rewrite>

This file will be on the same level as the web.config.

Within your new config file, simply specify the rules as they would have been in the web.config originally. The following sample is the entire contents of the new rewrite.config file.

<rules>
  <rule name="RemoveTrailingSlashRule1" enabled="false" stopProcessing="true">
    <match url="(.*)/$" />
    <conditions logicalGrouping="MatchAll" trackAllCaptures="false">
      <add input="{REQUEST_FILENAME}" matchType="IsDirectory" negate="true" />
      <add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />
      <add input="{REQUEST_FILENAME}" pattern="(.*?)\.svc$" negate="true" />
    </conditions>
    <action type="Redirect" url="{R:1}" />
  </rule>
  <rule name="LowerCaseRule1" enabled="false" stopProcessing="true">
    <match url="[A-Z]" ignoreCase="false" />
      <action type="Redirect" url="{ToLower:{URL}}" redirectType="Permanent" />
  </rule>
</rules>

Now you have a nice separation of concerns setup, and are no longer beholden to having to edit the web.config file whenever an IIS rewrite rule needs added, modified, or removed.

ConfigSource for Other Web.Config Elements

As a brief mention, the rewrite rules section of the web.config is not the only one you can use configsource with! Many, many other sections in the web.config support this feature, and you can read more about configsource in general at Microsoft’s documentation page.

The post ConfigSource Your Rewrite Rules appeared first on Falafel Software Blog.

This is post 7 of 17 in the series “Google Cloud for the .NET Developer”

Introduction

So you’ve decided to port your ASP.NET 4.x Azure Web Apps to the Google Cloud Platform (GCP). The only option available today for hosting non-Core ASP.NET in GCP is with Windows Server VMs in Compute Engine. Let’s start by acknowledging that this is a move from a Platform as a Service (PaaS) to Infrastructure as a Service (IaaS), with all the typical tradeoffs: in short, you sacrifice rich features in exchange for increased granularity of control. With that in mind, let’s take a look at some of the most fundamental tasks in deploying and managing a cloud-based app: publishing to a cloud testing environment and then deploying a production version to a load-balanced, auto-scaling cluster.

Publishing an ASP.NET Web App to a Windows Server VM in GCP

In another topic, I talked through the steps to take to create a new Windows Server VM ready to run ASP.NET applications in GCP. By the end of those steps, you should have created a Windows user account and gotten back a random password. You now have everything you need to publish an ASP.NET application to the Windows Server VM, straight from Visual Studio. Select your web app, then select Build | Publish… to open the Publish dialog. Under “Select a publish target”, choose Custom. Fill in the Server and Destination URL using the Site address in the Deployment Manager.

And fill in the User name and Password with the Windows user you created and the password generated by GCP. Fresh out of the box, IIS is configured with a single web site named “Default Web Site”. Use that as the Site name.

And that’s it! Click Publish, and Visual Studio will build and publish the web app to IIS on the VM. After publishing, your default browser will automatically open the Destination URL.

Common additional steps

Enable SSL

Most web sites and applications these days support SSL or even insist upon it. You will have to take a few extra steps to enable this in your Windows Server VM. If you already know your way around IIS, then you know how to do this. However, if you’re coming from Azure, you might not. Here’s a quick visual guide.

1. In the Site Actions menu, click Bindings…
2. In the Site Bindings dialog, click Add…
3. In the Add Site Binding dialog, set the Type to “https”
4. Select an SSL certificate. GCP Windows Server instances come with a self-signed certificate that you can use for development, but for production you’ll want to purchase a certificate signed by a widely recognized Certificate Authority (CA).

Enable URL Rewriting

Another common scenario that goes hand-in-hand with enabling SSL is forcing SSL by using URL Rewriting. This is enabled by default in Azure, but not in IIS. In fact, if you have an app that includes URL Rewriting in web.config, your app will simply not work until you enable this feature in IIS. The error you’ll see will simply state “HTTP Error 500.19 — Internal Server Error. The requested page cannot be accessed because the related configuration data for the page is invalid.” The easiest way to enable it is to use the Web Platform Installer to search for “URL Rewrite” and install it.

Of course, lacking the URL Rewrite module is not the only cause of a 500.19 error. Other configuration-related errors including malformed or invalid XML may also result in this error.

Preparing for Horizontal Scaling

To me, deploying to a single instance in the cloud for testing fills a pretty similar role to having a staging slot in Azure. It’s probably OK that the staging environment is a single instance, but in production you’re probably going to want so scale on demand or even automatically. Let’s take a look at the steps needed to create an auto-scaling, load-balanced cluster from that staged web app. There’s already a great walkthrough in the GCP dotnet docs. Don’t be intimidated; in spite of the length, it is not a complicated process–merely a multi-step one.

I stepped through the walkthrough myself, but rather than using the bookshelf sample app, I wanted to deploy a super-simple app that just reported the IP address of the host that handled the request so I could see for myself that requests were being distributed across instance group members. Whenever the walkthrough said to enable API access, I skipped those, because my app didn’t use any GCP APIs. I also chose “None” for Session affinity to get a round-robin distribution, to more easily observe that traffic was going to the 2 instances I requested for the group I created. Once it was all set up, I could see my VM instances created by the instance group.

And navigating to the IP address of the load balancer resulted in a page that reported back one of the two internal IP addresses.

According to the documentation, traffic will continue to be routed to the same host for the duration of the session. I was able to confirm this by refreshing the page and observing that the address did not change. Then I navigated to the load balancer’s IP address in an incognito window and got back the other instance’s IP address.

Scaling an ASP.NET web app–or any other app in VMs–is currently a manual multi-step process that can’t be fully automated due to the need to RDP into the target VM to run GCESysPrep. There is also currently not a really good story for rolling out updates to instance groups yet; the Instance Group Updater service is currently in alpha. I hope to see it become ready for production use soon!

Conclusion

As you may have noticed, while it is possible to migrate an ASP.NET 4.x web app from Azure to GCP VMs, it comes at the cost of some conveniences that you may have taken for granted in Azure. This is obviously a bit of an unfair comparison since the same could be said about Azure Web Apps vs Azure VMs. A closer comparison would be moving an ASP.NET Core Web App from Azure to GCP App Engine Flex, but that’s better left as the topic of another post.

The post Porting Azure Web Apps to Google Cloud Platform (GCP) appeared first on Falafel Software Blog.

This is post 6 of 17 in the series “Google Cloud for the .NET Developer”

Intro to GCP Compute Engine

If you’re a Windows .NET developer, then when you think cloud, your first thought is probably Microsoft Azure. However, Google Cloud Platform (GCP) has a very strong offering for Windows developers as well, starting with one of the most fundamental building blocks of cloud computing: the Virtual Machine (VM). The Google Cloud Platform’s name for VMs in the cloud is Compute Engine. It might be intimidating to step into an arena largely populated by unfamiliar Linux servers and enough foreign programming languages to populate a veritable Tower of Babel, but let me reassure you: working with Windows Server VMs in GCP is extremely friendly and approachable. In this tour, I’ll act as your friendly guide to show you some of the things that I like and appreciate about the VM management experience in GCP. Just so you know where I’m coming from: I’m happier and more comfortable writing code than wrangling infrastructure, so if I can find things to love about managing VMs in GCP, then I bet you can too.

Creating Windows Server VMs

There are two main ways to create a new VM in GCP: by creating a new instance from the Compute Engine | VM Instances tab, or by using the Cloud Launcher. The difference here is that the Cloud Launcher offers a catalog of preconfigured VM images with additional software installed, whereas creating a new VM instance in the Compute Engine tab will get you a VM with nothing more than the selected OS installed.

Creating an Empty VM

For ASP.NET development, it will generally be more convenient to use the Cloud Launcher to take advantage of the pre-configured images, but let’s take a quick look at creating a plain VM first.

Here you can see the basic options available. The machine type dropdown actually controls both vCPU and memory in lockstep, but you can create custom combinations of CPU and memory if you desire. Below that is the boot disk configuration where you choose operating system, disk type (standard or SSD) and disk size. Finally, to the right is a terrific itemized breakdown of the cost, so you can quickly and interactively see how the options you choose affect the price. Lastly, I want to call attention to this little nugget at the bottom because it’s easy to miss and yet so appreciated.

After you interactively configure a VM, you can click these links to get a modal window that contains the exact REST or gcloud command so you can automate creation of identical VMs in the future. You’ll find thoughtful little concessions like this sprinkled throughout the GCP UI.

At this point you can click Create to provision a brand-new Windows Server with nothing installed.

Creating an ASP.NET VM with Cloud Launcher

Now let’s take a look at what you get by using the Cloud Launcher to create an ASP.NET VM. Cloud Launcher will both create a VM with the configuration you specify, and also customize that VM with additional software and configurations. Right now, you can find the image in the Cloud Launcher just by searching for “asp”.

As you can see in the text on the card, this image includes IIS and ASP.NET. The inclusion of SQL Express is simply to make it easy to get started with ASP.NET in GCP, because obviously you can’t and won’t scale an app without a common database–at least in most cases. Clicking on the card will bring up a more complete set of information including a pricing projection based on the default configuration. Unfortunately, if you choose to customize the image before creation, you won’t get to see an updated pricing projection like you can with the Compute Engine UI. I’ll create one with the default configuration so you can see how to manage one of these VMs.

Managing Windows VMs in the Google Cloud

Whether you create a bare Windows Server instance or use the Cloud Launcher, you will end up in the Deployment Manager. On the right side of the page, just under the instance info, there is a button with a dropdown button on it.

Available options are:

• RDP
• Create/reset password
• Show gcloud command to reset password
• Download RDP file

The first thing you should do is actually create a Windows password. See how once again the UI shows you how to automate this task? I love that! Once you create a Windows password, you can manage the instance remotely. The two main options available are “RDP” and “Download the RDP file”. The first option will launch a browser-based RDP session, while the second will download a file that contains all the info you need to connect with your local, native RDP client. This is not the only place where a browser-based alternative is available; every GCP account can also launch a browser-based terminal session with a Linux-based environment with many essential developer tools pre-installed and a persistent home directory. You could in theory do all your work on a Chromebook! I mean, you probably wouldn’t, but it’s still nice.

Once you’re at the point where you can connect with RDP to the VM, it’s just like managing any other Windows Server. I’ll write separately about my experience migrating an ASP.NET web application from Azure App Services to a VM in GCP.

The post Google Cloud Platform (GCP) Compute Engine – Windows Server VMs appeared first on Falafel Software Blog.

This is post 5 of 17 in the series “Google Cloud for the .NET Developer”

Now that we understand how to authenticate a C# application to work with your own project’s GCP resources, let’s take it a step further. In this post, we’ll look at how we can combine that connectivity with end user data, via three-legged OAUTH authorization, to perform operations on user content, with their permission of course.

For this example, I’ve created a very simple ASP.NET MVC project that logs a user in, gets their profile image, and uploads it to a specific bucket. Let’s take a closer look at each part.

Creating API Credentials

Before we can ask a user for permission, we have to first configure our application with a Client ID and Secret so that we have the necessary elements to complete the OAUTH workflow. This is done by visiting the API Console and creating a new OAUTH Client ID:

If you haven’t already configured your OAUTH consent screen, you’ll be prompted to do so. This is required because the authorization request needs to show the user the name of your application, so that it’s clear that you are the one asking for permission:

Now you can proceed to configure the new key, in this case for a Web Application. You need to specify a valid path (within your website) to receive the callback redirect URI to send the user after they grant permission:

For our application, this is represented by the path: http://localhost:4078/Login/Callback.

After a user authorizes our app to access their account, Google will redirect them back to this path to complete the OAUTH workflow, sending with it a code that we need to validate the request (more on this later).

Once this is configured, you’ll be given a Client ID and Secret that you’ll need to safely store where it’s accessible only by your site (and not checked into source control or otherwise published!).

To keep things simple we’ll embed them in our code, but you’ll definitely want to protect this on a production site.

Authenticating the User

Now that our application is configured to properly request for access, we need to go ahead and create a way to initialize the OAUTH workflow for our users.

I added a simple LoginController that takes care of asking the user to authorize our application to access their account. This controller simply constructs the authorization URL on the trusted Google domain that the user will use to login and authorize the app.

Here’s what the code looks like for the Login Controller with this default action to start the authentication process:

public class LoginController : Controller
    {
        // CLIENT ID AND SECRETSHOULD NOT BE STORED IN CODE OR CONFIG, use Default Credentials or other safe method
        private const string CLIENT_ID = "[CLIENT-ID-KEY-FROM-API-MANAGER]";
        private const string CLIENT_SECRET = "[CLIENT-SECRET-KEY-FROM-API-MANAGER";

        // the bucket we're using to store images
        private const string BUCKET_NAME = "falafel-test-profile-images";

        public ActionResult Index()
        {
            // Build the login oauth url
            var scopes = "email profile";                               // what we want to access
            var redirectUrl = "http://localhost:4078/Login/Callback";   // the url to which Google should send the user back to complete authentication
            var clientID = CLIENT_ID;                                   // SHOULD BE IN A SAFE PLACE, NOT HERE!

            // redirect user to the login url
            var oauthUrl = string.Format("https://accounts.google.com/o/oauth2/v2/auth?scope={0}&redirect_uri={1}&response_type=code&client_id={2}", scopes, redirectUrl, clientID);
            return Redirect(oauthUrl);
        }
    }

When the user visits this page, they’ll be redirected to the constructed url, which will proceed to ask them to login and authorize your application (using the name you configured on the consent screen):

Once they grant access, Google will redirect them back to your site via the Callback URI that you configured when setting up the API credentials. It’s our job to take that code and validate it by posting it (along with our app Secret and other parameters that validate the code) to another Google endpoint.

Here’s the code for the Callback action that handles this request:

public async Task<ActionResult> Callback(string code)
        {
            // build the request to validate the incoming code
            var clientID = CLIENT_ID;                                   // from the Google API console, SHOULD BE IN A SAFE PLACE, NOT HERE!
            var clientSecret = CLIENT_SECRET;                           // from the Google API console, SHOULD BE IN A SAFE PLACE, NOT HERE!
            var redirectUri = "http://localhost:4078/Login/Callback";   // the original url we sent must match what we original set as the callback
            var grantType = "authorization_code";                       // this tells OAUTH we're using a code to validate


            // wrap parameters in a Form object
            var content = new FormUrlEncodedContent(new[]
            {
                new KeyValuePair<string, string>("code", code),   // the code we got from the callback
                new KeyValuePair<string, string>("client_id", clientID),
                new KeyValuePair<string, string>("client_secret", clientSecret),
                new KeyValuePair<string, string>("redirect_uri", redirectUri),
                new KeyValuePair<string, string>("grant_type", grantType),
            });

            // the url to send the POST request (from the google docs)
            var postUrl = "https://www.googleapis.com/oauth2/v4/token";

            // submit the request
            var client = new HttpClient();
            var result = await client.PostAsync(postUrl, content);

            // get the result as a string
            var resultContent = await result.Content.ReadAsStringAsync();

            // parse the result into an object
            var resultObject = new { access_token = "" };
            var json = JsonConvert.DeserializeAnonymousType(resultContent, resultObject);

            // use the token to get the user's profile
            var url = "https://www.googleapis.com/oauth2/v1/userinfo";
            client.DefaultRequestHeaders.Add("Authorization", "Bearer " + json.access_token);
            var response = await client.GetStringAsync(url);

            // parse the new result to get the profile
            var profileResultObject = new { picture = "", id = "" };
            var profileJson = JsonConvert.DeserializeAnonymousType(response, profileResultObject);

            // upload the image to the storage bucket
            await UploadProfileImage(profileJson.picture, profileJson.id);

            // redirect to a result page
            return RedirectToAction("Images", "Home");
        }

Once we have the user’s permission (via the access_token property) we can use that to get their profile information, including their profile image. We use the Google Cloud C# API (authorizing as we described in the previous topic) to upload that profile (via a Stream object) directly to our storage buckets.

This is the code for the UploadProfileImage method that performs the upload to Google storage:

private async Task UploadProfileImage(string url, string id)
        {
            // get the keyfile
            var path = Server.MapPath("~/Falafel Test Project-b53a21babe66.json");

            // authorize a client
            var credential = GoogleCredential.FromStream(new FileStream(path, FileMode.Open)).CreateScoped(new string[] { StorageService.Scope.DevstorageReadWrite });
            var storageClient = StorageClient.Create(credential);

            // set the destination bucket, file name and content type
            var destination = new Google.Apis.Storage.v1.Data.Object();
            destination.Bucket = BUCKET_NAME;
            destination.ContentType = "image/jpeg";
            destination.Name = id + ".jpg";
            
            // get the image stream
            var httpClient = new HttpClient();
            var resultStream = await httpClient.GetStreamAsync(url);

            // upload the stream to the destination bucket as public
            storageClient.UploadObject(destination, resultStream, new UploadObjectOptions() { PredefinedAcl = PredefinedObjectAcl.PublicRead });
        }

Finally, we redirect the user to new action on the Home controller that uses the same authentication to read the images uploaded to the bucket and show them to the user. Here is the code:

public ActionResult Images()
        {

            // the bucket we're using to store images
            var BUCKET_NAME = "falafel-test-profile-images";

            // get the keyfile
            var path = Server.MapPath("~/Falafel Test Project-b53a21babe66.json");

            // authorize a client
            var credential = GoogleCredential.FromStream(new FileStream(path, FileMode.Open)).CreateScoped(new string[] { StorageService.Scope.DevstorageReadOnly });
            var storageClient = StorageClient.Create(credential);

            PagedEnumerable<Objects, Google.Apis.Storage.v1.Data.Object> images = storageClient.ListObjects(BUCKET_NAME);

            return View(images);
        }

And here is what the resulting page looks like after our first user logs in:

Caveats and Wrapping Up

Of course, since this is a very simple example, we haven’t done any error checking (such as if the user has already uploaded their image), nor do we do any file locking to ensure multiple people aren’t attempting to read the key file (the result of which should probably be cached) which would probably cause an exception. If you were deploying this to a GCE or GAE instance, you could probably leverage the Default Application Credentials (from the previous topic) to authorize access to your storage account (which is certainly the recommended option)!

Finally, of course, we are embedding the Client ID and Secrets right inside our code, which is certainly a security risk and should never be done on a production site.

However, this hopefully shows how easy it is to authenticate a custom ASP.NET website to use both GCP services as well as client user accounts together to create a solution entirely driven by Google APIs.

A more thorough look at Google Storage and other Google services is coming soon, so stay tuned for more. In the meantime, as always, I hope this was helpful, and thanks for reading!

The post Authenticating Your C# Application for the Google Cloud Platform – Part 2 appeared first on Falafel Software Blog.

This is post 4 of 17 in the series “Google Cloud for the .NET Developer”

The new C# libraries for the Google Cloud Platform, available on NuGet, make it easy to get started adding these features to your platform. However, before you can use them, you obviously need to authenticate your application for access.

Google uses OAUTH 2.0 as the protocol for authentication In this post we’ll discuss the different scenarios you may encounter, and the different options available for authorizing your application.

Server to Server Authentication

If you are building an application that is leveraging GCP infrastructure as its platform, you only need to authorize your application to your own Google project. For example, you may be building an app that stores data in a Google Cloud Storage, owned by you, setup for your own application.

Sample Project

To demonstrate this, I’ve created a very simple project that reads the list of buckets in a Google Storage account and writes them to the console. Here’s the code which uses the StorageClient API:

class Program
    {
        private const string PROJECT_ID = "falafel-test-project";

        static void Main(string[] args)
        {

            try
            {
                var client = StorageClient.Create();
                var buckets = client.ListBuckets(PROJECT_ID);
                foreach (var bucket in buckets)
                {
                    Console.WriteLine(bucket.Name);
                }
                
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }

            Console.ReadLine();
        }
    }

Note the Project ID property, which you can retrieve from your project dashboard:

Of course, if we run this code now, without authorizing it first, we’ll get an error like this:

System.InvalidOperationException: The Application Default Credentials are not available. They are available if running in Google Compute Engine. Otherwise, the environment variable GOOGLE_APPLICATION_CREDENTIALS must be defined pointing to a file defining the credentials. See https://developers.google.com/accounts/docs/application-default-credentials for more information.

To fix this, we need to first authorize our application. The recommended (and simplest) option to achieve this is to leverage Google Default Application Credentials.

Google Application Default Credentials

The preferred method for authentication your application is to leverage the Google Application Default Credentials via the gcloud utility, which is part of the Google Cloud SDK. Be sure that you have already installed the SDK on your machine before proceeding.

Beta Tools

As of the writing of this entry, the command to configure the Google Application Default Credentials are still in beta. Be sure to check that option during installation of the SDK to ensure the command is available:

Alternatively, if you installed the SDK without this option, you can manually add the beta tools by running this command via the SDK:

gcloud components install beta

Note: If you have issues, try running the command as an Administrator.

Once the SDK is installed, run this command to start the process:

gcloud beta auth application-default login

This will launch a browser to start the authentication process.

Log in with the Google credentials associated with your project, and when complete your machine will be setup to access the GCP resources you have enabled for each project. This is done by downloading a file with the associated credentials to your machine (AppData for Windows).

It’s important to understand that this authorizes your entire machine to access your projects via the credentials you authorized. The good news about this is that as new projects are added or updated), your credentials automatically grant access, meaning you don’t have to continuously run the utility to access new project resources from your custom applications.

Now that your machine is authorized, you can call the cloud APIs directly, without any authentication credentials, as they will automatically pull them from your authorized machine. You simply need to specify the project id, and of course, have enabled desired service for the project.

If we run the same project again (after creating a few empty buckets in the storage dashboard), we’ll see our list of buckets as expected, without having to specify any authorization credentials to the code:

There are two significant advantages to this setup. First, you don’t have to concern yourself with accidentally checking in important, secret keys to source control, as they are stored in your local machine.

Second, both the Google App Engine and the Google Cloud Engine are already configured to use the same credentials, so if you are deploying your application to either of these services, your app will “just work” without having to manage config files or settings for the different environments.

Of course, this does mean that if you have more than one environment (or additional developers with their own environments) that each needs to remember to perform this step so their projects have access.

Revoking Default Credentials

If your work is done or you want to deauthorize a machine, you can do so via the same command-line utility, as described here: https://cloud.google.com/sdk/gcloud/reference/auth/application-default/revoke

Simply run this command and your machine will be deauthorized (the JSON file will be deleted).

gcloud auth application-default revoke

Setting Default Credentials Manually (Service Account Key)

If you do not have the SDK installed or are unable to install it for whatever reason, you can still leverage the Default Credentials by downloading the service key file manually from your account, and setting an environment variable pointing to its location.

To do this, start by going to the API Console Credentials page for your project: https://console.developers.google.com/project/_/apis/credentials

Create new credentials, selection the option for “Service account key”:

You will be prompted to select or create a service account (more on this later) which will be the account used to access your resources. For now we’ll use the default credential created by Google when we setup the project.

Select JSON for the key type and create the credential, saving it to a specific location you can find later. In my case I saved it to C:\Google.

Next, create an environment variable, pointing to the file at the location you saved:

Note: You may need to reboot before this variable is available.

Now you can run the project again and it will successfully authenticate and run.

However, it’s important to understand the difference between using the Service account key and the Default Credentials. Whereas the Default Credentials will authorize against your entire Google account, the Service account key authorizes against a specific service account defined for a particular project.

If you attempt to change the project id to one to which the service account does not have access, you’ll get an error like this:

The service storage has thrown an exception: Google.GoogleApiException: Google.Apis.Requests.RequestError
Forbidden [403] Errors [
Message[Forbidden] Location[ – ] Reason[forbidden] Domain[global] ]

This also means that you can only authorize one service account at a time, so be sure that you are leveraging the appropriate key and location.

Upon deployment to GAE or GCE, your code will again “just work” because as mentioned previously these environments are already configured for access.

Note: If you have both Default Credentials setup AND added the environment variable specified here, the environment variable will take precedent and this credential will be used instead of any others.

If you’re deploying to a different environment over which you don’t have direct control to set the environment variables, you’ll need another way to authorize your application, and for that we will need a service account.

Creating a Service Account

A Service Account is a credential (including a unique email address) you create that will be used to access GCP resources in a specific project. Although the Default Credentials are simple, and recommended you may have need to explicitly authorize your application against a specific credential. One reason in particular is if you need to access resources from more than one account in the same application, or as an account different that the default one associated with the machine.

To create a credential for your own project you need to open the Service Accounts page here: https://console.developers.google.com/permissions/serviceaccounts

Note: If you are using Google Compute Engine, a default service account will automatically be created for you.

You must first select the project, either by clicking the button labeled “Select a project” or selecting one from the “Project” dropdown menu at the top. Creating an account brings up a dialog to define it:

You can assign specific roles if necessary, as well as enable G Suite Delegation if you’re using it (more info here), but for now we just want to generate the keys that we’ll need to authenticate the platform.

You can choose between JSON and P12 formats for the private key. However, it appears that for the new .NET libraries, only the JSON option is supported (P12 is for legacy applications not using the new libraries), so we’ll select that option.

Upon creation, the appropriate file will be immediately downloaded to your machine. This is the only time the private key will be generated and available, so keep it safe!

Now that we have a service account created, we can proceed to use the keys to create Google Credentials for accessing GCP services of the project.

Creating Credentials from JSON Key

To generate the Google credentials, your C# application needs to be able to access the JSON key file. For our example, I’ve added the key to the project, copying it to the output directory on build.

Now all I need to do is use this file to generate the appropriate credential and pass it to the service. Here is the modified code, changing just the first two lines inside the try/catch to use our key file instead of the Default credentials:

static void Main(string[] args)
        {

            try
            {
                var credential = GoogleCredential.FromStream(new FileStream("Falafel Test Project-1c0bc1595ad8.p12", FileMode.Open))
                    .CreateScoped(new string[] { StorageService.Scope.DevstorageReadOnly });
                var client = StorageClient.Create();


                var buckets = client.ListBuckets(PROJECT_ID);
                foreach (var bucket in buckets)
                {
                    Console.WriteLine(bucket.Name);
                }
                
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }

            Console.ReadLine();
        }

Running the project now reveals the same result, assuming of course that we are using the proper key for the account that has access to this project.

You’ll want to be careful when using this option, because obviously you now have your private key exposed inside the project; be sure to exclude this from source control!

Wrapping Up and Next Steps

There are several options for authenticating C# applications to access the Google Cloud Platform. While the Google Default Credentials are simple, powerful, and above all recommended, if you need more control over the authentication process, you can authorize your applications against specific service accounts by creating private keys for each application.

In this case we’ve authorized our application to access our own account resources, also known as two-legged (server to server) authentication. If your application needs to access, process, or edit resources of an end user, we need to first ask for permission. This is called three-legged authentication, and is the subject of our next post.

Until then, as always, I hope this was helpful and thanks for reading!

The post Authenticating Your C# Application for the Google Cloud Platform – Part 1 appeared first on Falafel Software Blog.

This is post 3 of 17 in the series “Google Cloud for the .NET Developer”

At the end of the day, like most APIs you encounter in the wild, Google services are exposed as standard REST endpoints. If you know how to create, authenticate, and issue an HTTP request, you have everything you need to add Google’s extensive list of services (including the Google Cloud Platform) to your applications.

However, most developers prefer to spend their time focused on the implementation of their application, and would rather skip mucking around with boilerplate code to create raw HTTP requests, serialize requests and responses, and handle errors. Depending on how many services an application consumes, such operations can represent a significant amount of development time.

Fortunately, like most popular public APIs, Google offers a Software Development Kit (SDK) for a majority of their services, for many different languages and platforms, including .NET via C#. In fact, the Google APIs Client Library for .NET has been around for a while, offering C# libraries for Google Services including the Google Cloud Platform.

Brand New Libraries for Google Cloud Platform

The Client Library for .NET offers a collection of libraries for accessing established services like YouTube, Calendar, etc. However, although this library collection does include support for various Google Cloud services, there is now a new set of .NET libraries for the Google Cloud Platform available here: https://cloud.google.com/dotnet

The new C# libraries, led by noted C# expert and Microsoft MVP Jon Skeet, offer a full-featured C# experience for developers looking to leverage GCP in their applications. These libraries are also open source, and available on GitHub for developers to clone as well and contribute to the project. There is also API documentation available including the list of supported products and their release status (beta, alpha, etc.).

As of the writing of this post, the original .NET Client Library is still supported for GCP, and many of the new libraries are in beta or alpha stages. However, it is still recommended that you leverage the new libraries, especially for new projects, as these are the libraries that will be updated and supported in the future.

Getting Started Guides

Each supported product has a page to get you started, documenting installation, authentication, and even sample code demonstrating usage of the library. These are linked from both the project Github homepage and the API Documentation page.

As of the writing of this post, the following libraries are available, separated by release status:

Late Beta

• Google Cloud Storage
• Google BigQuery
• Google Cloud Datastore
• Google Stackdriver Logging

Beta

• Google Cloud PubSub
• Google Cloud Natural Language
• Stackdriver Monitoring
• Stackdriver Error Reporting
• Stackdriver Trace
• Google Cloud Diagnostics for ASP.NET

Alpha

• Google Cloud Metadata
• Google Cloud Vision
• Google Cloud Speech

Nuget

Each of the Google Cloud libraries is available via Nuget, so adding them to your project is as simple as right-clicking your project, selecting Manage Nuget Packages, and searching for the desired library.

Note: Be sure to select the option to “Include prerelease” since many of these libraries are still in beta/alpha stages.

It’s also important to note that your search may reveal the original libraries for .NET, so be sure you’re selecting the correct library (many of the new packages serve as wrappers to the older libraries, so they may also be included as dependencies). The newer libraries have an updated logo and namespace, so be sure to look carefully at the naming to ensure you’ve selected the correct one.

Tutorial Project

As a helpful resource to get you started, Google has created a complete C# sample that leverages several cloud services together in one project for you to test, run and deploy to GCP. There is also an associated, thoroughly detailed, step-by-step tutorial available that guides you through each facet of the project as well as the Google services they leverage. You get a full tour of several services including live deployment and even resource scaling.

If you’re new to GCP, this is a fantastic place to start, so I encourage you to read through the entire interactive tutorial to quickly get familiar with the Google Cloud Platform.

Bookshelf App Tutorial

In addition, there is a collection of C# samples available on Github here: https://github.com/GoogleCloudPlatform/dotnet-docs-samples

Wrapping up and Next Steps

The Google Cloud Platform has a lot to offer C# developers, and the library refresh makes it easier than ever to integrate these services into your applications. Although still in early form, these libraries are growing quickly, both in terms of availability and quality, and easily installable via Nuget so you can start using these today!

However, although installation of the supported libraries into your own projects is easy enough, there’s an important step we have to complete before they can actually be used: Authentication. That will be the subject of a future post so stay tuned!

Until then, as always, I hope this was helpful, and thanks for reading!

The post C# Support for the Google Cloud Platform appeared first on Falafel Software Blog.

This is a great way of reading application initialization data and writing log data in a test apparatus and laboratory setting. Particularly when a network or internet connection is not reliable or available in your test apparatus/laboratory setting. You can manage application settings by editing a simple JSON file at your convenience and copying it onto a thumb drive. Then just plug it into an IoT device-based system. Data gets read and written to the thumb drive and is easily accessible by just removing the thumb drive.

The first thing you need to do to your Windows Universal application is enable a couple of capabilities.

Fig 1

The “Pictures Library” and the “Removable Storage” capabilities need to be enabled. Why the “Pictures Library”? Because, as of build 14393, you can’t read or write files other than what are recognized as those that belong in the “Pictures Library” when you have that capability enabled. If you enabled the video or music capabilities, you could write those kind of files as well. There is no option for text, doc, or any other files. In this example, we’re going to stick with picture files.

Now you need an initialization file to put onto your thumb drive. We’re going to set key/value pairs in a JSON format. In this example, we’ll have a value that updates our page title, an integer value, and the log filename.

{
“MAINPAGETITLE”:”My Removable Title”,
“MAININT”:3,
“LOGFILENAME”:”MyLogFile”,
}

Create a new text file in your favorite editor, but when you save it to the root of your thumb drive make sure you save it with a .jpg extension. This is what it should look like.

Fig 2

Your system will recognize it as a .jpg, which is OK because we know it’s just JSON data hiding.

In your application you need to create a class to handle the JSON data in your file.

Fig 3

To read the JSON file from the thumb drive, we need to add the following method with the name of our file as a parameter.

Fig 4

Fig 4-1: Call GetFoldersAsync from the KnownFolders.RemovableDevices object to get a reference to all of the removable drives.
Fig 4-2: Get a reference to the thumb drive by looking for a drive whose name contains “USB DISK”.
Fig 4-3: To open the file, we call the CreateFileAsync method.
Fig 4-4: Now we open a stream reader from our opened file with a call to OpenStreamForReadAsync.
Fig 4-5: Read stream content with a call to ReadToEndAsync.
Fig 4-6: Finally, we populate the data from our file into a reference of our MyAppData class with a call to DeserializeObject.

With this call in place you can update the app data class and the JSON file with anything you need to initialize your application in most anyway you want.

In this example, we write our data file into a new folder for each day. In order to write data to the thumb drive we need to add the following method.

Fig 5

Fig 5-1: In this example, I create a new folder for each day. This line builds a folder name using the filename as a prefix followed by the month, day, and year.
Fig 5-2: Just like reading the JSON file in Fig 4, we need to get a reference to all the removable drives and find the USB thumb drive.
Fig 5-3: We create the daily folder with a call to CreateFolderAsync and get a reference to it.
Fig 5-4: Now we create the data file in the new daily folder with a call to CreateFileAsync.

The following method shows how easy it is to writing data to our file.

Fig 6

Fig 6-1: Open a stream to our data file with a call to OpenStreamForWriteAsync.
Fig 6-2: Now that we have a stream opened to our file, writing to the file follows a standard procedure of writing to a DataWriter and flushing the stream.

To demonstrate how to use these functions we have a simple Universal Windows App example that we’ll run on a Raspberry Pi2, or other suitable Windows IoT Core device. The XAML for our app has just three elements. We have a TextBlock to display our title, a Button that executes our write procedure, and a TextBox to store the data that we’ll write to our data file. Note that we’re defaulting the IsEnabled property of the button to False.

Fig 7

In the Loaded event handler, we open and read our app file and initialize our data file.

Fig 8

Fig 8-1: We call our OpenAppFile method with the name of our app file.
Fig 8-2: Now that our AppData reference is loaded with the data from our file, we set our title TextBlock and set our integer value to our TextBox. No binding for this example; we’re keeping it simple.
Fig 8-3: We call our InitLog method to initialize and create the data file for writing.
Fig 8-4: We use the ContinueWith task method to set the IsEnabled property to True after the InitLog method is completed.

In the button click event handler we write to our data file

Fig 9

Fig 9-1: First we set our button IsEnabled property to False to prevent double clicking.
Fig 9-2: Now we call our WriteLogAsync method to write our data to our data file.
Fig 9-3: We use the ContinueWith task method to set the IsEnabled property of the button to True after the WriteLogAsync method is completed.

With the software in place and our JSON file saved to our thumb drive, it’s time to plug it into our Pi2 and run our application.

Fig 10

When the app first comes up, you should see this something like this.

Fig 11

Now you can write something to the data file by filling in the TextBox and pressing the Write Log button.

Fig 12

Remove the thumb drive, plug it into your computer, and browse to your thumb drive. The computer will think your data file is a .jpg. However, we know that it’s not. Right click on the data file and open with the text editor of your choice.

Fig 13

Now you can view your data.

Fig 14

I found this very useful for an automated electronic tester we were building. This tester was going to be in a factory setting where a reliable internet connection was not an option. We needed to be able to collect the data and have a way to store it on removable media that could be uploaded to headquarters at a convenient time. We also needed a way to be able to update the app settings day by day. In any case, this work around proved very useful for our situation. Maybe it will be useful for one of your needs someday. You can download the sample app here.

The post Read/Write data from/to USB thumb drive on a Windows IoT Core device appeared first on Falafel Software Blog.

This is post 2 of 17 in the series “Google Cloud for the .NET Developer”

The list of products available in Google Cloud Platform, while shorter than the lists from Azure or AWS, can still seem quite daunting. Here’s a quick overview of what’s available in the Google Cloud Platform (GCP) specifically for .NET applications.

Compute

GCP offers many products under the Compute umbrella, but most are not easily accessible to the Windows Server + IIS + .NET developer. The two main offerings of interest are Compute Engine and App Engine.

Compute Engine

Compute Engine is the family of services focused on the management of VMs in the Google Cloud. This is truly Infrastructure as a Service (IaaS). This includes single instances, instance images, snapshots, disks, instance templates, and auto-scaling instance groups. In GCP, you can create Windows Server VMs, and the licensing and activation are handled entirely by GCP and simply rolled into the cost of the VM. This is the only way to run .NET 4.x in GCP.

App Engine

If Compute Engine is Infrastructure as a Service, App Engine is Platform as a Service (PaaS). With App Engine, the focus is more on running your code in managed environments and less about the management of the metal itself. In addition to that, App Engine adds automatic health checks, scaling, traffic splitting, memcache, logs, task queues, and more. You can write new ASP.NET Core applications that can be hosted in App Engine’s flexible environment with what they call a custom runtime–in this case, requesting the official Microsoft .NET Core Images from the repository.

Storage

Once you get past the limited support for Windows and .NET in GCP, everything else really starts to open up. There’s a NuGet package for every GCP service, making it easy to consume them from any .NET project. Here are some of the available storage options:

Networking

GCP offers a variety of networking services, including virtual private networks, load balancing, Content Delivery Networks (CDNs), the ability to create a network that enables interconnectivity between GCP and external infrastructure, and even the ability to manage Domain Names.

Big Data

In addition to Cloud Bigtable, GCP offers several other services that support the unique needs of big data.

Machine Learning

The GCP Machine Learning family of services includes a multitude of APIs that encapsulate models already trained to perform tasks such as analyze natural language, convert speech to text, translate languages, recognize things in images, and more. Then there is the Machine Learning Service, currently in beta, which allows you to train your own model using the TensorFlow framework.

Management

GCP offers a unified management service called Stackdriver, which enables monitoring, logging, error reporting, tracing, and even in-production debugging (debugging not available for any .NET languages, sadly). It also offers Cloud Endpoints, a service that lets you define a RESTful API and then surrounds that with authentication, logging, and monitoring. The implementation of the API can be hosted on App Engine Flexible, which in turn can contain ASP.NET Core applications.

Developer Tools

For the ASP.NET developer, GCP offers a cross-platform CLI, a Visual Studio extension, and tools for PowerShell.

Identity & Security

GCP has its own implementation of Identity and Access Management (IAM) called Cloud IAM. Out of the box, it offers not only standard roles for users, but also specialized roles and fine-grained control relative to specific GCP resources. For example, you can create an IAM access control policy that grants the Subscriber role for a specific Cloud Pub/Sub topic. Cloud IAM automatically creates a full audit trail of permissions as well.

That covers the highlights of what’s available on GCP, especially the products of interest for .NET developers. There are even more that I glossed over or are bundled with other products as well. Check out the full list at http://cloud.google.com/products.

The post Google Cloud Platform (GCP) Overview appeared first on Falafel Software Blog.

This is post 1 of 17 in the series “Google Cloud for the .NET Developer”

Cloud services reduce the effort needed to manage infrastructure, provision servers and configure networks. Today the cloud market is primarily dominated by Amazon Web Services, followed by Microsoft Azure. As the new kid on the block, GCP is the newest entrant to a highly profitable and competitive landscape.

Our team at Falafel Software have built applications for our clients on both Amazon Web Services (AWS) and Microsoft Azure for some time. Because of Falafel’s stellar reputation, we have been selected as the first West Coast partner for Google Cloud Platform (GCP) .NET solutions. As part of our partnership with Google, we will offer training, mentoring and consulting for the Google Cloud.

In this blog series, the team will discuss GCP services and implementation differences between GCP, AWS, and Azure. This post explores GCP from a business point of view — what to consider when making an informed decision for your organization.

Why go with Cloud computing?

For a company to remain competitive, it needs to reduce costs, increase business agility and remain flexible to handle growing needs. Infrastructure-as-a-service (IaaS) or public cloud services, are an indispensable part of your IT arsenal that allow you to focus on your core business. Here are 5 reasons to move to the cloud:

• Business Efficiency – Freeing your organization from managing a large IT department allows you to efficiently run business operations and focus on decision making that affects the future of your company. You free yourself, and your team, from worrying about how business activity impacts IT.
• Reduce Staffing – Keep only the key technical specialization and engineering staff that your business requires, without adding operational personnel.
• Scaling – To handle seasonal spikes, unexpected growth, or other changes in traffic, use cloud services to ramp up resources without purchasing hardware and software that goes unused during the rest of the year.
• Reduce Capital Spending – Why make large capital investments for hardware, data centers, and staff when you can use the savings for business investment? Instead of risky large outlays, your cost is reduced to monthly billing.
• Instant Anywhere Access – Cloud services allow your team to work anywhere with instant access. Team members only need internet connections and authorized access. This means better work conditions, a larger pool of talent (they can work remotely from anywhere) and more efficiency at getting things done.

Why GCP?

We were invited to meet with Google at both their Chicago and Mountain View headquarters to discuss GCP from a .NET perspective. Since then, we have decided to move one of our applications from Azure to GCP, in part to see how easy it would be to migrate from one solution provider to another, and to compare performance between the two.

Although GCP is relatively new compared to AWS and Azure, Google has been beefing up their cloud offering. Not only has Google added new data centers worldwide since last year, they also offer one of the best pricing models. GCP does not require upfront payment or a lock-in commitment and offers discount for sustained usage. GCP charges you monthly for on-demand usage of instances by minutes used (minimum of 10 minutes). Google offers a sustained-use discount and publically promised to pass along along to their customers any future price reduction. In contrast, AWS offers several pricing models; on-demand usage priced by the nearest hour, reserved instances – a commitment based pricing for a specific VM instance, and spot bidding for extra capacity available. Azure offers per minute billing with pay-as-you-go subscriptions, buying from a reseller, and an upfront usage commitment paid in advance or monthly.

Let’s talk about services. The array of storage options are impressive: from arbitrary objects (Google Cloud Storage), to relational databases (MySql, Sql Server), BigQuery (used by Google Analytics and SnapLogic), and BigTable ( “NoSql” database used by Google Search and Gmail). You have storage options for cost-efficient data storage based based on frequency of use and the geographic location of your customers.

GCP and .NET

Google also supports .NET technologies like SQL Server, Windows Servers, Visual Studio tools and offers a developer stack featuring IIS, SQL Express and ASP.NET. You can also use Google’s Cloud APIs (with tons of supported libraries), Cloud Tools for Visual Studio and a even work in PowerShell using the Cloud Tools for PowerShell extension. It is impressive to see that Google is pushing for a more robust .NET environment, with help from people such as Jon Skeet and other notable developers. To learn more, check out this article: Making ASP.NET apps first-class citizens on Google Cloud Platform.  

For more details on porting between cloud platforms, using APIs with .NET and other tips, watch for upcoming blogs in this series.

Adoption Costs

There are inherent adoption costs to consider. While all three platforms offer common features like schema-less, NOSQL tables, each has its own flavor: Google’s BigTable vs. Amazon’s DynamoDB vs. Azure’s DocumentDB. They’re very similar at one level, but not identical. There are differences in indexing, access and storage structure that can incur migration and training costs.

“In theory, there is no difference between theory and practice. In practice, there is.”

On one hand, there might be little new learning if your engineers already know a specific tech stack (e.g. .NET or Java or Node.js). While cloud platforms can be accessed in a variety of programming languages, some implementations are easier to use. Google is growing it’s list of “idiomatic” client libraries that are true to the flavor of each language, particularly .NET.

Likewise, infrastructure management operations performed by IT are unique to each platform. Azure has it’s “Blades” web user interface, while AWS and GCP have a more standard web console. As Adam noted in our intro report on Google Cloud Platform, the GCP portal feels like a middle ground between Azure and AWS’s portal:

“My initial impression is that the GCP portal feels more approachable and snappier than the Azure portal. Another really impressive thing is how Google has really gone all out to make their tooling really accessible directly within the browser.”

Hybrid Cloud

Private servers are costly and difficult to scale, as opposed to public clouds. But you may be reluctant to give up private services and storage that are known to work well for critical applications. In this case, you might consider a hybrid cloud environment that uses a mix of public cloud with your own on-premise, private solutions. By moving the workload between the two, you can limit computing needs and manage cost more efficiently. This gives you greater flexibility and more options to deploy data when and where you need it. For example, you could use a cloud provider to host your development environment and less critical data.

Security

Security is one checkbox that no organization can afford to skip. GCP has numerous International Organization for Standardization certifications for its cloud security. The standards serve as assurance that Google has taken specific internal measures to secure its users’ data and protect it from unwanted intruders. GCP has the following certifications: SSAE16 / ISAE 3402 Type II, ISO 27001, ISO 27017, ISO 27018, FedRamp ATO (Google App Engine), PCI DSS v3.1 and conducts annual audits with an independent auditor.

Google also supplies fully integrated Identity and Access Management(IAM) and security scanning.

What can Falafel do for you?

Falafel’s expertise in .NET is widely known, having worked with the industry’s best companies for many years (See “Great Companies Choose Falafel” on our main page). Falafel will be the first Google Cloud Partner on the West Coast to provide GCP solutions for Windows and .NET.

Need help to implement and manage the Google Cloud Platform? We can train your staff, work alongside you (mentoring), or simply build the entire solution for you:

• Migration Planning – We work with you to design a strategy that effectively and safely migrates your data to the cloud.
• Migration Execution – With our expertise and experience, data migration can be done with ease and a peace of mind. Let us move your data for you.
• Compute Engine Configuration – We can configure multiple virtual machines that your team can access any time.
• End-to-End Solutions – Our senior engineers have years of experience developing solutions that take full advantage of the flexibility, scalability and cost effective power of the cloud.

Besides being a GCP .NET cloud implementation service, Falafel will continue to give back to the development community — watch for our blog posts, guides, ebooks and learning sessions.

Planning for the future

Although Google Cloud Platform is the new entrant to the public cloud space, it offers tons of capability, resources, and competitive pricing that is attractive to businesses considering a move to the cloud or switching from AWS or Azure. Google has put strong emphasis on growing its cloud platform and we will only see improvement from here on. Anticipating the future for your business begins with making the correct business decision. The first step starts here. Why not take a free spin with Google Cloud and see the benefit for yourself?

Contact us with any questions or if you need help with your cloud implementation at support@falafel.com. We’re happy to help.

The post Why Organizations should choose GCP – A Business Perspective appeared first on Falafel Software Blog.