Archives
-
Transform your IIS into a real-time pub/sub engine with Faye-Node
Faye is a simple Http Pub/Sub server initially implemented by John Coglan in Ruby, and also later ported by himself to Node.js. The version for Node.js implements the Bayeux protocol, which at first glace, many of us known as http long polling.
-
A Simple backup tool for SQL Azure
If you are using SQL Azure nowadays, you probably know that there are only a few alternatives for making backups of your existing data.
-
Leveraging NuGet as a central repository for PowerShell modules
We have been working a lot lately with PowerShell as part of our star product at Tellago Studios, “Moesion”. One of the main features we provide in Moesion is the ability to execute PowerShell commands remotely in a given server using a web mobile interface (You can read more in my previous post about Moesion).
-
Initial thoughts on the Windows Azure Accelerator for Web Roles
Deployment is considered today as one of the major pain points in the Windows Azure platform. A simple application deployment today can take around 20 or 30 minutes to complete, and to make the things even worse, there is not support for partial updates meaning that a simple change requires a complete upgrade or deployment. The Windows Azure team has recently introduced the support for web deploy in the platform to deal with this issue. Using Web Deploy, you can deploy a complete application or part of it in an existing web role instance in a matter of seconds, which is a huge improvement to what we had so far.
-
Using Windows Azure Regions efficiently
Moving your application to the cloud might not be easy as it sounds. The typical sample we always see in documentation or demos about an ASP.NET application created from the Visual Studio template and deploy it in Azure as a package is definitely very far from reality. There are multiple factors that can affect the response time and availability of your applications in the cloud but you can not easily see until you embark on a real project. Application distribution and deployment is one of those factors, and the one we are going to discuss in this post.
-
Custom domains for Azure Hosted Services
A hosted service in azure is typically assigned with two public addresses, one for the production environment with a DNS name ending in cloudapp.net such as [your name].cloudapp.net and an auto generated DNS name for the staging environment such as 4969aae4e18f4699aa88223e1e73ba8e.cloudapp.net. There are multiple reasons you might want to map your custom domain name to these public names in Azure, but these are the most common ones I can imagine,
-
Pub/Sub in the cloud for IT Management
In the recent “Build” event, Microsoft introduced a new feature Windows Server 8 known as “Windows Powershell Web Access” for exposing a the server powershell console through a web interface. Although this feature looks very promising in first place, I only think it is convenient for intranet scenarios. I don’t initially see an organization exposing their servers directly to internet for using this feature from a phone as it represents a high risk.
-
Making WCF Web Async Apis
One of the hidden gems that you can get today from the WCF Web Api source code in codeplex (wcf.codeplex.com) is the support for the task-based asynchronous model introduced in .NET 4.0. The new model simplifies a lot the way you do asynchronous stuff in .NET, and it’s going to get even better with the async support in C# 5.
-
Running the “Express” web development framework on Node for Windows
As some of you might know, with the release of Node version 0.5.2, there is now support for Windows. It’s a single executable “node.exe” that you need to start using node on your machine, and you can get it from this location.
-
Hosting your own Pub/Sub in the cloud with AppHarbor and Hermes
As you might read in my latest post, Hermes is one our new pet projects in Tellago for doing Pub/Sub over http. The idea is simple, but still very useful for integration scenarios in the enterprise. The fact that Hermes is all based on Http and uses one of the most famous open source initiatives for NoSQL databases like MongoDB, makes this project very appealing for the cloud as well. Many of the cloud platforms already provide MongoDB as a service that you can use in your applications hosted in the cloud.
-
Hermes – A new open source alternative for doing pub/sub over Http
After a few months of collaborative work across several members in our Tellago crew, Hermes is finally here. Hermes, also known as the great messenger of god in the Greek mythology, was the name we gave to this new open source alternative for doing durable pub/sub messaging over http.
-
Telesharp – An Application Repository for .NET applications
A year ago, we released SO-Aware as our first product in Tellago Studios. SO-Aware represented a new way to manage web services and all the related artifacts like configuration, tests or monitoring data in the Microsoft stack. It was based on the idea of using a lightweight SOA governance approach with a central repository exposed through RESTful services.
-
Interop Bindings for WCF released in codeplex
I am happy to announce that one of the projects in which Microsoft and Tellago have been collaborating together during the last few months was released as part of wcf.codeplex.com. The primary aim of this “WCF Interop Bindings” project is to simplify the work needed for making WCF services interoperable with other service stacks like Oracle WebLogic, IBM Websphere, Metro or Apache Axis.
-
To push, or not to push, the Web Socket dilemma
Web Sockets is a relatively new specification introduced as part of HTML 5 to support a full duplex-communication channel over http in web browsers. This represents a great advance toward real-time and event driven web applications. Before Web Sockets jumped in scene, the only available solutions for emulating real time notifications in web applications were different variants of Http Long polling. Real time notifications in this context became particularly important for specific scenarios, such as reporting stock pricing updates, online gaming or news reports to name a few.
-
Pub/Sub in the cloud–A brief comparison between Azure Service Bus and PubNub
Publish/Subscribe in the cloud has became relatively important lately as an integration pattern for business to business scenarios between organizations. The major benefit of using a service hosted in the cloud as intermediary is that publishers and subscribers don’t need to be publicly addressable, be in the same network or be able to talk each other directly. The cloud infrastructure allows this intermediary service to scale correctly as the number of publishers or subscribers increase, and also to act as a firewall for brokering the communication (Publishers or subscribers need explicit permissions to connect, send or receive messages from the intermediary service).
-
Integrating ELMAH with MongoDB
MongoDB is by far one of the most well-known and powerful documental databases created in the open source community. The simplicity that you find in this database is also another factor that help a lot in adoption, as you don’t need to know much to start using it.
-
Extending the SO-Aware repository with custom metadata
One of the main features that SO-Aware provides is the central repository for storing service artifacts (WSLD, schemas, bindings) and configuration that any organization generates. This central repository is completely exposed as an OData service that third party applications and tools can easily consume using Http.
-
Caching strategies for SOAP and REST Services
SOAP services are in nature transport agnostics so they can not rely on specific transport features. Http is a great example where SOAP services make a poor use of Http as application protocol. This means that many of the http constraints are simply ignored, http headers are not used at all, messages are not self descriptive (You can not easily infer what a message does by looking at the content), the uniform interface is not used either as everything goes as a POST to the server and the list keeps growing. This makes impossible to leverage the existing web architecture and use intermediaries for caching results.
-
Don’t use services unless you necessarily need them
There are multiple factors or requirements that might lead you to refactor some functionality into services. Here are some examples,
-
Making the HttpMessageHandlerFactory in WCF Web Apis more DI friendly
The HttpMessageHandlerFactory shipped out of the box in the WCF Web Apis Preview 4 can only construct channels instances with a single argument in the constructor representing the inner channel in the pipeline.
-
We have IQueryable, so why bother with a repository
The repository pattern became popular a couple of years ago by the hand of Eric Evans with the DDD (Domain Driven Design) movement and Martin Fowler with his catalog of Enterprise Application Patterns.
-
Tellago upcoming webinars
We are happy to announce a new program “Technology Updates” as part our plans to help developers and IT people to adopt new technologies.
-
Second round of Web Http Caching
As I discussed in my previous post, web caching relies on specific headers that you need to use correctly on your services. That’s an http application protocol thing, and something that you can easily use in any application framework that treats Http as first citizen. This means that you don’t need to implement anything fancy or exclusively rely on an specific caching technology or components for doing ouput caching (e.g ASP.NET Cache).
-
Implementing caching in your WCF Web Apis
One of the beauties of using Http as application protocol when building Web Apis is that you can reuse all the available infrastructure in the web to make your services scalable to the extreme. Caching is one of the fundamental aspects that makes scalability possible in the web today because it provides the following benefits when it is implemented correctly,
-
Configuring your WCF Web Apis
Another major improvement in this new WCF Web Api release is the introduction of a fluent API for configuring your WCF Web Apis. All the available extensibility points in the current bits are now exposed through this API making possible to easily discover them.
-
Http Message Channels in WCF Web Apis Preview 4
The new WCF Web Apis Preview 4 released yesterday in the wcf.codeplex.com introduced a new extensibility point for intercepting messages at channel level. The name for this new feature is “Http Message Channels” and the good thing is that you don’t need to rely anymore on the REST Starter Kit request interceptors for doing the same thing. Actually, a Http Message Channel is more useful as you can intercept either request or response messages, and also you get an Http message with all the context information you might need and not a WCF generic message, which usually requires some additional processing.
-
Troubleshooting your WCF Web Apis with AppFabric
In this last post, I showed how the new WCF Web Apis could be integrated with AppFabric for pushing custom events to the AppFabric tracking database. A great thing about the monitoring infrastructure in AppFabric is that is uses ETW as mechanism for publishing the events, so your services are not hitting the database directly with all the performance penalties that database calls imply.
-
My frustrations with MVVM in Silverlight
There is no doubt that the MVVM pattern offers a clean separation of concern for building testable user interfaces with WPF and Silverlight. This pattern relies on the data binding support in those two technologies for mapping an existing model class (the view model) to the different parts of the UI or view.
-
Making your WCF Web Apis to speak in multiple languages
One of the key aspects of how the web works today is content negotiation. The idea of content negotiation is based on the fact that a single resource can have multiple representations, so user agents (or clients) and servers can work together to chose one of them.
-
Service Testing made easy with SO-Aware Test Workbench
I happy to announce today a new addition to our SO-Aware service repository toolset, SO-Aware Test Workbench, a WPF desktop application for doing functional and load testing against existing WCF Services.
-
Monitoring your WCF Web Apis with AppFabric
The other day, Ron Jacobs made public a template in the Visual Studio Gallery for enabling monitoring capabilities to any existing WCF Http service hosted in Windows AppFabric. I thought it would be a cool idea to reuse some of that for doing the same thing on the new WCF Web Http stack.
-
Authenticating clients in the new WCF Http stack
About this time last year, I wrote a couple of posts about how to use the “Interceptors” from the REST starker kit for implementing several authentication mechanisms like “SAML”, “Basic Authentication” or “OAuth” in the WCF Web programming model. The things have changed a lot since then, and Glenn finally put on our hands a new version of the Web programming model that deserves some attention and I believe will help us a lot to build more Http oriented services in the .NET stack. What you can get today from wcf.codeplex.com is a preview with some cool features like Http Processors (which I already discussed here), a new and improved version of the HttpClient library, Dependency injection and better TDD support among others.
-
SO-Aware Service Explorer – Configure and Export your services from VS 2010 into the repository
We have introduced a new Visual Studio tool called “Service Explorer” as part of the new SO-Aware SDK version 1.3 to help developers to configure and export any regular WCF service into the SO-Aware service repository.
-
Workarounds for supporting MVVM in the Silverlight ContextMenu service
As I discussed in my last post, some of the Silverlight controls does not support MVVM quite well out of the box without specific customizations. The Context Menu is another control that requires customizations for enabling data binding on the menu options. There are a few things that you might want to expose as view model for a menu item, such as the Text, the associated icon or the command that needs to be executed. That view model should look like this,
-
Workarounds for supporting MVVM in the Silverlight TreeView Control
MVVM (Model-View-ViewModel) is the pattern that you will typically choose for building testable user interfaces either in WPF or Silverlight. This pattern basically relies on the data binding support in those two technologies for mapping an existing model class (the view model) to the different parts of the UI or view.