MSDNBRUNEI.NET | Microsoft Developer Network Brunei

test captcha

admin — Fri, 18 Dec 2009 23:27:00 GMT

just test

Geneva Framework – Quick Intro

risman — Sat, 18 Apr 2009 11:56:13 GMT

This new stuff will make me busy for the next 7 weeks as we will have POC for that. For you how are new to Geneva, you can download it at connect.microsoft.com including all of its tutorials and guidance around claim-based identity. In claim-based paradigm, user presents an identity to application as a set of claims. One claim could be the user ID, emails, or another The main idea is that an external identity system is configured to give your application everything it needs to know about the user with each request she makes, along with cryptographic assurance that the identity data you receive comes from a trusted source.

Let see simple scenario. Let say, you are creating a weather web services with smart client model. Diagram below shows a claims-aware weather Web service (the Relying Party application) and a smart client that wants to use that weather service. The RP exposes a policy that describes its addresses, bindings, and contracts. But the policy also includes a list of claims that the RP needs, such as user name, e-mail address, and role memberships. The policy also tells the smart client the address of the STS from which it should retrieve these claims. After retrieving this policy (1), the client now knows where to go to authenticate: the STS. The user presents credentials (2) and the smart client makes a web service request (3) to the STS, requesting the claims that the RP asked for in its policy. The job of the STS is to authenticate the user and return a security token that gives the RP all of the claims it needs. The smart client then makes its request to the weather web service as the relying party (4), and sending the security token along in the security SOAP header. The weather service as RP now receives claims with each request, and simply rejects any requests that don’t include a security token from the issuing authority that it trusts.

We already know this concept in general. But what about if you are required to reuse existing user identity, for example Windows Live passport or you have list of website users in SQL Database? Yes.. Here is where Geneva Framework can help you. You can make your custom STS that can read claims store in database (maybe in legacy system) and also directory services. Geneva is not only about SSO or Federation, but more than that because you will be able to create custom STS that match to specific requirement.

What about interoperability? Several WS-* standards are used in the previous scenario. Policy is retrieved using WS-MetadataExchange, and the policy itself is structured according to the WS-Policy specification. The STS exposes endpoints that implement the WS-Trust specification, which describes how to request and receive security tokens. Most STSs today issue tokens formatted with Security Assertion Markup Langauge (SAML). SAML is an industry-recognized XML vocabulary that can be used to represent claims in an interoperable way.

See you in other Geneva story.

Cheers – RAM

Beginner Guide - C++ for Windows

risman — Sat, 11 Apr 2009 04:11:23 GMT

We have long weekend due to the election day in Indonesia. I use the time to refresh my C++ skills – language, design pattern and Win32. Actually, it was requested by one folk from Vietnam to drive C++ in our MSDN community. I agreed with him as we need to balance our MSDN contents for both native and managed development. If you like C++, below is my guidance on how to improve your C++ programming skills on Windows, assuming you already good in data structure and algorithm from school.

#1 – Be good in language

You don’t have to know all C++ language aspects to write C++ program. But to enable you write good codes, I do suggest you to master the language before learn design skills. I always consult to The C++ Complete Reference, The C++ Programming Language and C++ Primer for my language skills. Put attention to object oriented language features, generic/template and STL. I also use boost for other stuffs that is not included in standard libraries. Practice, practice and practice are the key.

#2 – Learn GoF design patterns

The well accepted basic catalog for design patterns came from Gang of Four. But most of developers have difficulties to learn GoF without real sample scenarios. I found the following website very useful for me as it has a lot of documentations and samples of GoF with C++. Click on the picture to go to the Vince Huston website. If you know other website, please help to put in the comment section.

#3 - Learn Win32

Most of feedbacks I got from community is, C++ is easy, but programming C++ in Windows is hard because of the nature Win32 API. Actually that is true. The hardest part of programming C++ on Windows is the learning Win32 and other Windows toolkits/frameworks like the platform SDK Win32, WDK, MFC, COM, WTL, and ATL that you will need in a real project. Framework selection will affect our design as we will not programming in vacuum. If you agreed with me, then the following resources will be your good friends:

- Programming Windows
- Windows System Programming
- Windows via C/C++
- Programming Windows with MFC
- Platform SDK Documentation. You can choose Vista, Windows 2008 or Windows 7 SDK.

I do believe that native development will still have its own place. But that is your own choice to become full managed code developer or combine it with native C++ knowledge. In our beloved MSDN community, I planned to balance it.

Cheers – RAM

.NET RIA Services with Offline Scenario?

risman — Sat, 04 Apr 2009 05:45:57 GMT

I am working to help some of physicists who run KucingFisika, to design their future multimedia e-learning site with Silverlight. After looking around for design practices, I found that Microsoft .NET RIA Services is good as our base line. This is now available and you can download from here and later explore it like I do. In this post, I would like to encourage you to see that we can add additional scenarios, making RIA Services really applicable in low bandwidth condition like us in Asia – adding offline feature. From marketing point of view:

Microsoft .NET RIA Services simplifies the traditional n-tier application pattern by bringing together the ASP.NET and Silverlight platforms. RIA Services provides a pattern to write application logic that runs on the mid-tier and controls access to data for queries, changes and custom operations. It also provides end-to-end support for common tasks such as data validation, authentication and roles by integrating with Silverlight components on the client and ASP.NET on the mid-tier.

From technical point of view (you can read more from its PDF documentation). It is a framework that provides patterns for writing LOB application logic and validation (by design). LOB applications use data that needs to flow across tiers. It may be created and used through basic CRUD operations or it may be accessed through domain-specific custom operations in encapsulated form such as an approval operation. In an internet application, there is a trust boundary between the client and the mid-tier server. Hence, it is important to have a stylized way to express what resources are available to the client tier and what operations are permitted. In addition to defining the resources and operations, a developer needs to validate the data as it is created or updated. The validation needs to run on the presentation tier for giving immediate feedback to the user and on the mid-tier for ensuring that the rules defined for the application are enforced. Thus, there may be common validation across the tiers as well as tier-specific validations that need to be integrated with the resources and operations.

Lets look at the anatomy of a common Web application compared to RIA. With a RIA, most of the presentation logic moves to the client to improve the UX and to make effective use of local state. The result is additional work for the developer: defining a full-fledged services layer, new types and contracts to share etc. and continually evolving them as the app evolves on either end. A RIA isn't just a client app, but an "Internet" app that includes a server component. This is where RIA Service guidance will give you values – end-to-end pattern for this additional work. But remember, there is no perfect design/pattern, we can always improve it based on our requirements.

The first part of RIA Services pattern is to write a DomainService class. This represents your application domain, your application logic, or business logic, a set of operations – CRUD based or custom domain-specific, DAL specific, authorization and validation. A DomainService is optimized to be stateless - to respond to query requests and to change set processing requests.

The second part of the pattern is what we generate - the client-side data model - in a DomainContext class. This class represents the view of what the client can see. It contains lists of objects, one for each type exposed to the client, and it contains a set of load methods that roughly correspond to the queries exposed on the service. These load methods can be used to load objects into the corresponding lists. The individual objects and lists track changes and raise change notifications. The DomainContext can extract all the changes, create a change set and submit it to the service for processing and committing. A DomainContext is optimized for taking advantage of the stateful environment and to be a well-behaved citizen in a binding-centric presentation technology such as Silverlight or WPF.

Nikhil Kothari describe .NET RIA Services vision as RAD for RIA, which is I totally agreed and have the same sense.But there is one requirement here in Asia that we must consider – low bandwidth condition. This will rise new scenario - offline-enabled RIA application, means that we need to add local storage scenario for the DomainContext. The design challenges of all the offline-enabled applications are:

How to isolate client data layer

What is actually the data layer in RIA? It that the API that server exposes to AJAX? Gears provides a good vision on Server Data Layer and Local Data Layer, controlled by a Data Switch. Gears propose JavaScript DB API with SQLite to enable local data storage. It is a good project to start with SQL Compact Edition, however, but an ActiveXObject should be created for SQL Compact Edition/SQL Express/ESENT. Anyone interested here?

Offline strategy – what features need offline scenario

This is the harder part for me, as closely related to our application scenarios. Let say, I want to design Physics e-learning application that contains RIA/Silverlight based simulation, Farseer Physics Engine for example. Some numerical calculation should be done at client side and its results should be store locally in order to feed parameters for responsive and dynamic GUI animation. You might think that you would always want to use the local store since it is faster. However, there are many practical reasons why you may want or need to access the data on server instead. For instance:

- Data may be so transient in nature that it makes no sense to cache it. I will use Project Velocity for cache anyway.
- Some Simulation's data makes sense only while online.
- The App may choose to store only the most frequently accessed data.
- Numerical computational and/or disk space requirements make it unfeasible to recreate the feature offline.

Typically, the optimal solution is to use the local store as much as possible, since it's usually faster than a remote connection. However, the more work an application does locally, the more code you need to write to implement the feature locally and to synchronize the corresponding data. There is a cost/benefit tradeoff to consider, and some features may not be worthwhile to support locally.

In fact, .NET RIA Service provide ready to extend set of capability that I like. But, a lot of work should be done to make it work like I want. That is my problem though :).

Application Modality

What is modality – feature to switch from online to offline states or vice versa. Modal applications usually indicated through some change in the user interface. The user is made aware of the state and participates in switching states in some manner. Modeless applications attempt to transition seamlessly between online and offline states, without significant UI changes. The user does not need to participate in switching states, which the application does automatically.

In a modal application, when the application is online it communicates with the server. When it's offline, it uses the local store. Data must be synchronized when the app switches between modes. The advantage of making a modal application is that it's “relatively simple” to implement and therefore a reasonable way to bootstrap the application to function offline. But some disadvantages are: The user must decide and remember to switch modes. Since the local store is not always up-to-date, it can't be used to improve the application's responsiveness when connected to the server.

Data Synchronization

What is the sync strategy for this kind of application? No matter which connection and modality strategy we use, the data in the local database will get out of sync with the server data. For example, local data and server data get out of sync when:

- The user makes changes while offline
- Data is shared and can be changed by external parties
- Data comes from an external source

There are many approaches to synchronization and none are perfect for all situations. We have Microsoft Sync Framework and Astroria Offline as candidates for reusable framework here (where I am still arguing). The most important thing for engineer to decide is manual or background synchronization. In manual sync user decides when to synchronize. It can be implemented simply by uploading all the old local data to the server, and then downloading a fresh copy from the server before going offline. In background sync, the application continuously synchronizes the data between the local data store and the server. This can be implemented by pinging the server every once in a while or better yet, letting the server push or stream data to the client. With Silverlight supports on WCF, this should be easy to implement.

Well, the next step for me is to gather our detail requirements and see how current frameworks can help. I am still hacking the MSF, Astoria Offline, RIA Services, and Velocity. For sure, I will share with you if I found interesting things.

Have nice weekend without insomnia!.

Cheers – RAM

Project Velocity – Answer to Memcached?

risman — Fri, 03 Apr 2009 17:15:47 GMT

Regarding my previous post about Memcached, Zeddy pointed me to Project Velocity. This is exactly what I am looking for!. A highly scalable in-memory, distributed cache cluster in farm deployment, high availability and of course, concurrency ready and x64 support!. Applications can store any serializable CLR object without worrying about where the object gets stored. Scalability can be achieved by simply adding more cache servers on demand. “Velocity” also allows for copies of data to be stored across the cluster, thus protecting data against failures. “Velocity” can be configured to run as a service accessed over the network or can be run embedded with the distributed application.

Key Features

"Velocity" consists of a cluster of servers that communicate with each other to form a single, unified application cache system. A client application can communicate with one or more of the servers in the cluster to perform cache operations such as Get, Put, or Remove. Multiple client applications can work with the same cached objects that use any of the servers in the cache cluster. The primary components of the physical model consist of the cache server, the cache host Windows service, the cache cluster, the PowerShell-based cache administration tool, and the cluster configuration storage location. The following diagram shows how all these elements relate.

- Caches any serializable CLR object and provides access through simple cache APIs.
- Supports enterprise scale: tens to hundreds of computers – with unified cache view from clients
- Configurable to run as a service accessed over the network or run embedded with the application.
- Supports common cache configurations.
- Supports dynamic scaling by adding new nodes.
- Configurable number of backup copies to provide high availability.
- Automatic load balancing.
- Integration with administration and monitoring tools such as ETW, System Center, etc.
- Provides tight integration with ASP.NET to be able to cache ASP.NET session data
- Follows the cache-aside architecture (also known as Explicit Caching) for V1.
- Support for multiple client languages (for example, PHP, C#, C++, etc.).

Key Scenarios : Social Networking Site and Enterprise LOB

Not only for social networking scenarios, Velocity was designed to support enterprise application.

High Availability Model

The logical model of the cache cluster consists of named caches, regions, and cached objects. In the diagram, named caches span all the cache hosts in the cluster, but regions are limited to just one cache host in the cluster. The high availability feature supports continuous availability of your cached data by storing copies of cached data on separate cache hosts, as illustrated in the next diagram.

With high availability enabled on a multi-server cluster, your application can still retrieve its cached data if a cache server fails. A copy of each cached object or region is maintained on a separate cache host. The cache cluster manages maintenance of these copies and supplies them to your application if the primary copies are not available. No code changes are required to make your cache-enabled applications highly available.

All "Velocity" cache hosts use TCP/IP to communicate with each other and support the cache cluster. To function correctly, each cache server needs firewall exceptions to be configured for the cache host service. Three separate ports are used: the cluster port, the arbitration port, and the cache port.

Client Types

In order to store data in the cache on a cache cluster, the System.Data.Caching.CacheFactory.GetCache(System.String) method is used to return a Cache object for you to work with in application code. Once instantiated, this Cache object is referred to as the cache client.

There are two types of cache clients: routing and simple. Each cache client also has the option to store cached data locally, which is named local cache. These cache client options are specified in the application configuration settings.

Deployment Models

Velocity” can be deployed as a service or embedded within the application. In cache service, client applications access the Velocity cache through client APIs (TCP/IP or pipes), just like Memcached. In embedded mode, application (like ASP.NET) provides host for Velocity. The distributed cache runs as part of the application (or container) and the memory for the cache is shared with that of the application.

Microsoft project code named "Velocity" offers many options for specifying and storing the configuration details that are used by the cache cluster and the client application. Cache-based applications have the option of specifying configuration information programmatically or by using an application configuration file. There are three options available for storing cluster configuration settings: in XML, in a SQL Server Compact data file, or in a SQL Server 2005 or 2008.

Performance Test

Below is the test result for Velocity. The application consisted of simulating lots of users on many distributed client computers. Each user thread performs operations like Get, Put, and Remove on a 20K payload. It is a plot of throughput as the load gradually increased and also as new servers were added. The throughput increases as the load increases until it reaches saturation and stabilizes. At this point, if we add more servers, load balancing kicks in and the throughput increases again and the response time goes down.

How to Start

For now, just install the Velocity in your machine and explore the sample codes. You can also refer to the following sources. Part of it is already referenced in this post.

- Download Velocity CTP 2 and Sample Codes
- Microsoft Project Code Named “Velocity”
- Microsoft Project Code Named "Velocity" Team Blog
- Velocity MSDN Documentation

I will show you more about Velocity in my next post.

Cheers – RAM

Qt 4.5 with Visual Studio 2008 (VC++ Express)

risman — Wed, 01 Apr 2009 17:51:28 GMT

Qt is a cross platform GUI toolkit from Nokia. Its SDK is available under an LPGL license, it means we can use it free of charge to develop proprietary, commercial, closed-source software (thanks to Nokia). However, the current LPGL release leaves some gaps in using Qt from within Visual Studio 2008. This is somewhat understandable given that Visual Studio integration was a commercial-only offering and Nokia has Qt Creator (and not Visual Studio). My problem with Qt Creator is it uses MingGW (gcc) compiler which is nowhere near as good as VC++ 2008. Also for Visual Studio background like me, who is not familiar with Qt creator, learning Qt Creator will take time. Thanks to Wiria and AK who brought Qt to my table for a review.

Qt GUI Toolkit is very useful to develop portable application (single source codes) for *NIX, MAC and Windows (including Windows 98 but not being tested for Windows 7). In this post, I will show you how to start using Qt SDK only with Visual C++ 2008, you can use FREE Visual C++ 2008 express too.

Build VC++ Version of Qt

- Download and install qt-sdk-win-opensource-2009.01.1.
- Install the SDK to default directory, in my case C:\qt\2009.01. I didn;t install MingGW and Qt Creator as I don’t need.

- Once QT and VisualStudio 2008 both are installed and ready, open the VisualStudio 2008 Command Prompt.
- Change directory to the Qt SDK installation folder in the Command Prompt. Usually it would be of the form "C:\Qt\2009.01\qt"
- Run Configure.exe to target platform win32-msvc2008. You can simply run by typing configure or using other options. For example:

C:\Qt\2009.01\configure -no-sql-sqlite -no-qt3support -no-opengl -platform win32-msvc2008
-no-libtiff -no-dbus -no-phonon -no-phonon-backend -no-webkit

- Build Qt for use with Visual Studio 2008 by typing nmake
- Configure and nmake will take time, be patient enough. In my case, I started to build 19.17 PM and completed on 23.47 (4:30 hours)!
- Once completed, Qt SDK is ready for Visual Studio 2008.

Build and Run the Qt SDK Samples

Once your Qt SDK is ready to be used you can see samples directory in your Qt SDK installation (usually, C:\Qt\2009.01\qt\examples) and then open the examples.sln file from your Visual Studio 2008. If double-clicking .sln file does not work, open it manually from your Visual Studio. There are a lot of samples from Qt SDK.

If you build and debug – calculator project of instance – you will notification that the application because QtGuid4.dll was not found.

To let Visual Studio knows the include and library files of Qt, add their paths to the:

Visual Studio Tools|Options|Projects and Solutions|VC++ Directories

section. Typically you would want to add C:\Qt\2009.01\qt\include to the Include, C:\Qt\2009.01\qt\lib to the libraries and C:\Qt\2009.01\qt\bin to the Executables sections. Also you can add C:\Qt\2009.01\qt\bin to the Path System variable so that the Qt dlls get probed correctly when loaded from your application.

A lot of Qt samples inside the SDK. Try to build and run those sample applications to see how powerful Qt as GUI Toolkit.

Using Qt’s Visual Studio 2008 Plug-in

You can try Visual Studio add-in RC version (this will be a commercial product) to get integrated Qt templates and visual IDE features in Visual Studio 2008. I will not cover in this post, but this tools is promising. I will show you in my other Qt-VC++ post.

Hope this helps!

Ciao – RAM

Insomnia? So.. take REST!

risman — Sun, 29 Mar 2009 03:49:04 GMT

If you are getting insomnia then you need to REST. For all types of insomnia (transient, acute, chronic), you need to take REST for a while. Yes, I will do later. But the REST is actually the one who made me insomnia.

I will post more after taking some rest, but for know, you can try to look on it:

- WCF REST Starter Kit
- A Guide to Designing and Building RESTful Web Services with WCF 3.5
- ADO.NET Data Services and Entity Framework How do I videos

Enjoy!

Cheers - RAM

FastCGI Application on Windows Azure

risman — Sun, 29 Mar 2009 02:39:09 GMT

FastCGI is a protocol for interfacing interactive programs with a web server like IIS. It is a variation of earlier Common Gateway Interface (CGI) and very useful to reduce the overhead associated with interfacing the IIS and CGI programs, allowing a server to handle more web page requests at once. Instead of creating a new process for every request, FastCGI can use a single persistent process which handles many requests over its lifetime. Processing of multiple requests simultaneously is achieved either by using a single connection with internal multiplexing (ie. multiple requests over a single connection) and/or by using multiple connections. Many such processes can exist, something that can increase stability and scalability, read more at Wikipedia and its original spec.

FastCGI is language and platform independent protocol (but mostly C/C++ in nature). Not too much development at protocol level of FastCGI as it is very stable protocol, but it can be use in many web application scenarios because it ca add two new benefits that can boost scalability and availability:

- Distributed computing: run FastCGI applications on a different machine
- Multiple and extensible roles: CGI applications compute the response to an HTTP request.

In this post, I will explain how to develop FastCGI on Windows Azure using C++. I took a simple FastCFI sample from Windows Azure SDK March 2009 CTP. The sample program is designed to run as a sub-process of a Windows Azure Web or Worker role. It is a simple web role that demonstrates running a FastCGI application. By reading this post, you will understand how to:

- Enabling native code execution within the service definition file
- Configuring FastCGI in the web.roleConfig file
- Calling the Microsoft Service Hosting Runtime Native Library from a native C++ code

Note: You can use MS C/C++ compiler and MSBUild to compile.
All the command scripts are ready in the sample. Or using VC++ build project.

The FastCGIApplication in this sample is pretty simple. It logs information and read configuration settings by calling Microsoft Service Hosting Runtime Native Library (msshrt.lib and ServiceHosting.h). The Service Hosting Runtime Native Library provides a native API for interacting with the role management agent and with the local storage resource in the Windows Azure environment or in the development fabric. You have to make sure Microsoft Service Hosting Runtime Native Library installed in you machine, usually at :

C:\Program Files\Windows Azure SDK\v1.0\

Its definition was located in FastCGIApplication.proj. If you are using x64 machine like me, you have to change the msshrt.lib location to (ServiceHostingSDKInstallPath)\lib\x64.

<PropertyGroup>
   <ServiceHostingSDKInstallPath Condition="'$(ServiceHostingSDKInstallPath)'==''">
      $(Registry:HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Microsoft SDKs\ServiceHosting\v1.0@InstallPath)
  </ServiceHostingSDKInstallPath>
   <ServiceHostingSDKInclude>%22$(ServiceHostingSDKInstallPath)\inc%22</ServiceHostingSDKInclude>
   <ServiceHostingSDKLib>%22$(ServiceHostingSDKInstallPath)\lib\x64\msshrt.lib%22</ServiceHostingSDKLib>
     <CPPCompiler>cl.exe /Zi</CPPCompiler>
   <OutputExe>FastCGIApplication.exe</OutputExe>
 </PropertyGroup>

Below is its main program:

#include "Common.h"
#include "FastCGI.h"
#include <stdio.h>
int __cdecl main(int argc, __in_ecount(argc) LPSTR argv[])
{
    Initialize();
    LogInformation("Starting FastCGI Processing");
    std::string msg = GetConfigurationSetting("MessageOfTheDay");
    FastCGI fastCGI(msg);
    fastCGI.ProcessRequests();
    LogInformation("Exited");
}

In the ProcessRequests(), this FastCGIApplication will calculte size of response based on information in message header, allocate memory for response, and define response from FastCGI server.

void FastCGI::ProcessRequests()
{
    FCGI_Header headerOfMessage;
    FCGI_StdOutErrorRecord message_StdErr;

    DWORD dwBytesWritten = 0;
    DWORD dwError = 0;
    DWORD dwResponseSize  = 0;
    DWORD dwRequestId = 0;
    PBYTE pBuffer;
    HRESULT hr = S_OK;
    while ( TRUE )
    {                        
        ZeroMemory( &headerOfMessage, sizeof( headerOfMessage ) );
        Recieve((PBYTE)&headerOfMessage, sizeof(headerOfMessage) );
        
        // Calculate size of response based on information in the message header
        dwResponseSize = ( headerOfMessage.contentLengthB1 << 8 )
            + headerOfMessage.contentLengthB0
            + headerOfMessage.paddingLength;

        if( dwResponseSize > 0 )
        {                
            // Allocate memory for response
            pBuffer = new BYTE[dwResponseSize + 1];
            if ( NULL == pBuffer )
            {
                dwError = ERROR_OUTOFMEMORY;
                Error("Could not allocate memory" );
            }
            ZeroMemory( pBuffer, dwResponseSize );
            Recieve(pBuffer, dwResponseSize );
        }    
        dwRequestId = (headerOfMessage.requestIdB1 << 8) + headerOfMessage.requestIdB0;

        // Switch based on header type and define your own response to each of the 
        //  messages from the FastCGI Server
        switch( headerOfMessage.type )
        {
        case FCGI_BEGIN_REQUEST :
            LogVerbose("FCGI_BEGIN_REQUEST");
            break;

        case FCGI_PARAMS :
            LogVerbose("FCGI_PARAMS");
            break;

        case FCGI_STDIN :
            LogVerbose("FCGI_STDIN");
            ProcessRequest(dwRequestId);
            break;

        case FCGI_NULL_REQUEST_ID :
            LogVerbose("FCGI_NULL_REQUEST_ID" );
            break;

        default :
            Error("Unhandled type obtained, quitting" );
            break;
        }
    } //end while
}

If you are using VC++, you can build the FastCGIApplication and debug your FastCGI_WebRole project. Make sure the the WebRole project has web.configrole where application full path is defined. Note that %RoleRoot% is point to the root of your WebRole project, the same location with web.configrole and web.config files:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.webServer>
    <fastCgi>
      <application fullPath="%RoleRoot%\FastCGIApplication.exe"/>
    </fastCgi>
  </system.webServer>
</configuration>

You also have to enable native code execution in Service definition file (ServiceDefinition.csdef), as shown in the following codes.

<?xml version="1.0" encoding="utf-8"?>
<ServiceDefinition name="FastCGI" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">
  <WebRole name="WebRole" enableNativeCodeExecution="true">
    <InputEndpoints>
      <!-- Must use port 80 for http and port 443 for https when running in the cloud -->
      <InputEndpoint name="HttpIn" protocol="http" port="80" />
    </InputEndpoints>
    <ConfigurationSettings>
      <Setting name="MessageOfTheDay"/>
    </ConfigurationSettings>
  </WebRole>
</ServiceDefinition>

Ok, other thing that you should check is your web.config file. Make sure you have defaultDocument pointed to index.htm and has mapped the path of FastCGIApplication.exe.

<?xml version="1.0"?>
<configuration>
  <system.web>
   <compilation debug="true"/>
  </system.web>
  <system.webServer>
    <!-- Setup index.htm as a default document. -->
    <defaultDocument>
      <files>
        <add value="index.htm"/>
      </files>
    </defaultDocument>
    
    <!-- Map a particular path to our FastCGI application. -->
    <handlers>
      <add name="FastCGI Sample" 
           path="MessageOfTheDay" 
           verb="*" 
           modules="FastCgiModule" 
           scriptProcessor="%RoleRoot%\FastCGIApplication.exe" 
           resourceType="Unspecified" />
    </handlers>
  </system.webServer>
</configuration>

Now let see what is inside the index.htm. It basically a simple HTML page with a link to MessageOfTheDay. There is no page like that, because FastCGIApplication.exe is the interpreter who will response to the HTTP request.

<h1>A FastCGI Application</h1>
    The path <a href="MessageOfTheDay">MessageOfTheDay</a> is an example FastCGI application.
    The applications use the native runtime API to log information 
    and read configuration settings. After clicking on this page you can examine the logs 
    to see information about the handling of the request.

Ok, now let give more instances in Service configuration file (<Instances count="4"/>) then debug the WebRole project to see the local development fabric.

Want to see this application running in cloud? Simple, right click on the FastCGI web role project, then click publish. Visual Studio will create a ready to deploy package for you (fastcgi.cspkg and serviceconfiguration.cscfg) then redirect your browser to Windows Azure cloud provisioning site. You will need .NET passport and Azure invitation code to get access to that site. I create my FastCGI project there and deploy the FastCGI application in 4 steps:

1. Create a new project

2. Set the hosted service name (URL)

3. Prepare a staging deployment

4. Upload the project package and service configuration

Make sure that everything is well deployed. Azure use an effective way of HTTP deployment.

For more information about deploying your package and developing on Windows Azure, I would like to recommend you the "How Do I?" Videos for the Azure Services Platform. Enjoy!

Hope this helps!

Cheer – RAM

PHP FastCGI on Windows Azure

risman — Sat, 28 Mar 2009 17:32:02 GMT

After downloading the latest Azure Developer Kits (March 2009 CTP), I am very excited to let you know that Windows Azure offers native code execution, including support for FastCGI and full trust. As developers, we can choose to write services in a native language such as C or C++ and publish them to Windows Azure in the same manner as any other service, but to be more specific, below is its native execution supports:

- Windows Azure supports the IIS 7.0 FastCGI module.
- We can host web roles that require an native interpreter like PHP.
- We can host web roles and worker roles written in managed code under Windows Azure full trust.
- A role running under full trust can call .NET libraries, read the local server registry, and call native code libraries.
- We can develop a service in native code and test and publish this service to Windows Azure.
- A role running native code can interact with the Windows Azure runtime

Sure, I will show you how to start working with PHP in Windows Azure. What you need to do before being able to follow this article is (I assumed you already have VS 2008 SP1 installed):

- Install the Hotfix: Support for FastCGI on Development Fabric
- Install the Hotfix: Native Debugging Improvements
- Install the Hotfix: Improve Visual Studio Stability
- Install the Windows Azure SDK (March 2009 CTP)
- Install the Windows Azure Tools for VS 2008 (March 09 CTP)

If you have installed previous version of Windows Azure SDK and Tools, please un-install it before then install the hotfixes before the new Windows Azure SDK and Tools. If you are done, you can move forward.

Hosting FastCGI Applications

Windows Azure supports IIS 7.0 FastCGI module, so we can host web roles that call applications written in native interpreted languages, such as PHP. To host a web role that runs FastCGI on Windows Azure, we will follow the steps below.

First, create a Cloud Service - Web Cloud Service project in VS 2008, then go to Service Definition file to set the enableNativeCodeExecution attribute to true. It will look like this:

<?xml version="1.0" encoding="utf-8"?>
<ServiceDefinition name="PHPAzure" 
   xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">
  <WebRole name="WebRole" enableNativeCodeExecution ="true">
    <InputEndpoints>
      <!-- Must use port 80 for http and port 443 for https when running in the cloud -->
      <InputEndpoint name="HttpIn" protocol="http" port="80" />
    </InputEndpoints>
  </WebRole>
</ServiceDefinition>

To enable FastCGI, add a web.roleConfig file in the root of the Web Role project, and specify which FastCGI application we will be using. Please Note that web.roleConfig is an optional file; it's only needed if we wish to enable FastCGI. After add web.roleConfig file, specify the absolute path to the PHP FastCGI application (php-cgi.exe).

To specify the absolute path, precede the interpreter file name with the %RoleRoot% environment variable. The %RoleRoot% variable returns the absolute path to the directory in which the role is running. This directory corresponds to the root of web role project, the same location as the project's web.config file and the web.roleConfig file. Below is the config for PHP FastCGI application:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.webServer>
    <fastCgi>
      <application fullPath="%RoleRoot%\php\php-cgi.exe"/>
    </fastCgi>
  </system.webServer>
</configuration

Note: The FastCGI application must be xcopy-deployable and contained in our project. In this case, it is in the “php” subdirectory and specified via the special %RoleRoot% environment variable. An xcopy-deployable version of PHP for Windows can be downloaded from http://php.net. After downloaded, extract it do the %RoleRoot%.

Once enabled FastCGI, we need to configure handlers for a web role running a PHP FastCGI application by adding them to the system.webServer section of our project's web.config file. The FastCGI module will then handle each *.php request type. To add handlers to the project's web.config file, locate the handlers element of the system.webServer element, and add PHP handlers within this section. Below is our web.config file looks like after modified to handle .php file extension :

<?xmlversion="1.0"?>
<configuration>
<system.webServer>
    <handlers>
      <addname="PHP via FastCGI"
           path="*.php"
           verb="*"
           modules="FastCgiModule"
           scriptProcessor="%RoleRoot%\php\php-cgi.exe"
           resourceType="Unspecified" />
    </handlers>
</system.webServer>
</configuration>

Now you are ready to create a PHP page. Lets make simple page using phpinfo().

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">

<head>
<meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
<title>PHP on Azure</title>
</head>

<body>
<?php phpinfo();?>

</body>

</html>

So our project will look like below:

Normally we should be able to invoke our FastCGI application using Visual Studio Debug Menu (Control-F5) and get the PHP welcome page. If you prefer to try without Visual Studio, Ryan Dunn has provide this cool manual way using *.bat files. You can change number of web role instances via a simple modification to the Service Configuration file <Instances count="3"/>, see get more scale.

Note : Becareful with some thread safe PHP extensions in you php.ini file, as it may cause APPCRASH like below. Let me know if you have this problem too.

For further exploration, I do recommend you this MIX 09 presentation : Building Web Application with Windows Azure. In his presentation, Steve Marx did a very cool PHP on Azure demo, Tweval. That is a real deployed PHP sample on Windows Azure.

Hope this helps!.

Cheers – RAM

Windows Filtering Platform

risman — Fri, 27 Mar 2009 11:17:52 GMT

Windows Filtering Platform. Why it is so exciting? Read below:

WFP enables inspection and modification of stream and packet data coming in. A stream can be paused and later resumed; parts of the stream can be permitted, blocked or replaced with different data. There can be multiple stream modifiers performing stream modification. The stream can be pended if more data is needed to make a filtering decision on the stream. A typical use of this would be an application that needed to screen the stream for unwanted words.

Packet modification is also supported by different re-injection APIs. In this case, the packet is cloned, modified and re-injected either in the send, receive or forward path. Packet modification can involve header modification (e.g. port, source, destination addresses for NAT scenarios) or payload modification (both content and size can change). Packets can also be pended and then injected at a later time or discarded at a later time depending on the filtering policies. [Anupama Vasanth, WFP Automation Developer/Tester]

Yes, it provides rich filtering interface but at the same time it also exposes a new set of socket-level security APIs that enable Windows Sockets applications to leverage with IPsec for securing traffic.

Traditionally, IPsec has been used to protect network traffic via central administrative configuration using local or Active Directory group policy. The Secure Sockets API is an extension to the Windows Sockets API that allows socket applications to directly control security of their traffic over a network. The API extension allows applications to provide security policy and requirements for their traffic, and query the security settings applied on their traffic. For instance, applications can use this API to query a remote peer’s security token and use it to perform application-level access checks, or client applications can simply specify the Server Principal Name (SPN) of the server to prevent any man-in-the-middle attacks. Today, applications can already secure their traffic by using SSL, etc. But in comparison, the Winsock extension has been designed to make it very easy for a network application to secure its traffic, with minimal additional code, while letting Windows Sockets abstract away the complexity. [Kartik Murthy, IPsec Developer]

Windows Filtering Platform (WFP) is available on Windows Vista and Windows Server 2008. With WFP we can examine or modify outgoing and incoming packets before additional processing occurs. By accessing the TCP/IP processing path at different layers in the protocol stack, we can more easily create firewalls, antivirus software, diagnostic software, and other types of applications and services. Figure below showed the extensibility of WFP that will be useful for third party ISV:

Below is collection of sample codes that will guide you how to use WFP with C++.

- Windows Filtering Platform Sample
- Firewall using Vista's Windows Filtering Platform APIs
- Windows Filtering Platform Stream Edit Sample
- Windows Filtering Platform MSN Messenger Monitor Sample
- Windows Filtering Platform Packet Modification Sample
- Windows Filtering Platform Traffic Inspection Sample

WFP will be more safe comparing to LSP. Enjoy the C++ samples :)

Hope this helps – RAM

HIS 2009 Will Come

risman — Fri, 27 Mar 2009 04:24:29 GMT

If you are not familiar with the Host Integration Server, you can learn from HIS official site. Currently there is a HIS 2009 RC version available from http://connect.microsoft.com/. HIS 2009 is fully integrated to Visual Studio 2008. Last time I worked on HIS project for screen level interface to mainframe (2370 protocol) and I found that much more features will come from HIS 2009. Screencast from HIS team below is very useful to give you ideas on data and application level integration to host systems.

- Acessing Offline Mainframe VSAM Data Using Host Integration Server 2009 Release Candidate
- Exposing Mainframe Applications as SQL Stored Procedures using HIS 2009 Release Candidate

In case you have a specific integration case to legacy in AS400/MainFrame in your company, feel free to put in comment below.

Cheers - RAM

April 1st – Tech Virtual Day

risman — Wed, 25 Mar 2009 03:48:19 GMT

Wow, this is great!. One Event. One Day. One World Developer Community. Defying All Challenges. Together. With more then 95 sessions in 5 tracks, all of current technologies. Click on the image below to register and here for the detail agenda.

Cheers – Risman Adnan

BizTalk 2009 Beta with Visual Studio 2008

risman — Sat, 21 Mar 2009 17:47:44 GMT

Finally, BizTalk Server 2009 supports the latest Microsoft application platform technologies, including Windows Server 2008, Microsoft Visual Studio 2008 SP1, Microsoft SQL Server 2008 and the .NET Framework 3.5 SP1. BizTalk Server 2009 also delivers expanded new connectivity options including new integration with Oracle e-Business Suite, as well as updated platform support for the most recent versions of IBM Customer Information Control System (CICS), Information Management System (IMS), DB2, DB2/400, DB2 Universal Database and WebSphere MQ. You can download BizTalk 2009 Beta Evaluation version at Connect.Microsoft.com.

BizTalk Server 2009 delivers improved scalability and reliability through support for SQL Server 2008, Windows Server 2008 Hyper-V virtualization and enhanced failover clustering. It also provides significant new enhancements to both individual and team productivity by enabling new interoperability with ALM solution: Visual Studio Team System and Team Foundation Server 2008. This allows development teams to utilize the integrated source control, bug tracking, team development support, Project Server integration, and support for automating builds via MSBuild for a more seamless development and testing experience.

In this post, I will guide you to install BizTalk 2009 Beta and start working with it using Visual Studio 2008. First, you have to download BizTalk 2009 with its components (UDDI services, adapter pack, accelerator) from connect website. Before you download and install BizTalk 2009, I assumed you already have the following in your machine:

- OS                 : Win Svr 2008, or Vista SP1 with all critical updates.
- IIS                 : IIS 7.0
- VS 2008 SP1: Install C# or VB.NET
- SQL 2008     : Default installation. SQL 2005 is also applicable.
- Sharepoint    : WSS 3.0 SP1 or MOSS 2007 SP1

I am using Windows Server 2008 x-64 with VS 2008, SQL 2008 and MOSS 2007 installed.

Install BizTalk 2009

After installed IIS, VS 2008, SQL 2008 and Sharepoint (WSS/MOSS), you are ready to install BizTalk 2009. Remember that you also have to install BizTalk Redistribution Pack (download links for pre-downloaded CAB are listed in BizTalk 2009 installation guide) if some pre-requisites are not installed in your machine.

In my case I installed all the BizTalk core components for single server installation including BAM, Dev Tools and SDK, Documentations, Server runtime and additional software. If everything ok with your installation, you can launch the BizTalk Server configuration wizard. But before we configure BizTalk, something need to be done.

When using the SQL Server shared memory protocol with BizTalk Server 2009 you might experience degradation in performance under certain stress conditions, if clients are accessing SQL Server from the same computer. To resolve the problem you need to disable the use of the shared memory network protocol in the SQL Server Client Network Utility. After you disable the shared memory protocol, you will need to restart SQL Server services.

Configure BizTalk 2009

In this task, I will show you how to configure BizTalk Server 2009 using the Basic configuration option. Basic configuration is recommended for developers setting up a complete installation of BizTalk Server running on a single server. When configuring BizTalk Server 2009 using basic configuration, consider the following:

- Configuring a remote SQL Server is not supported.
- Configuring against SQL Server 2008 default instances and named instances is supported.
- Account you are logged on is local administrators and have System Administrator rights on SQL Server.
- The account you are logged on must be a member of the OLAP Administrators on the OLAP box if configuring.
- You cannot configure BAM Analysis on a SQL Server named instance using basic configuration.

When you use the basic configuration option, the following occurs:

- All database names are generated by BizTalk Server.
- All applicable database logon information is run under the account provided.
- All BizTalk Server services are generated by BizTalk Server.
- All BizTalk Server services run under the account provided.
- All features are configured based on the prerequisite software you have installed on the computer.
- The logged on user must be a member of the OLAP Administrators group on the OLAP server.
- The Default Web Site in Internet Information Services (IIS) is used for any feature that requires IIS.

The implication of the last point is we need to extend Default Website as a virtual server. WSS/MOSS uses virtual servers to host Web sites on server. The process of applying WSS/MOSS to a virtual server is called extending. We must extend a virtual server with WSS/MOSS before we can create a Web site based on WSS. We can do that in MOSS with the following steps:

- Go to Microsoft WSS/MOSS Central Administration.
- Navigate to the Application Management page.
- Under SharePoint Web Application Management, select Create or Extend Web Application.
- On the Create or Extend Web Application page, select Extend an existing Web application.
- On the Extend Web Application to Another IIS Web Site page, Select Change Web Application.
- On the Select Web Application page, select SharePoint Central Administration 3.0, and then click OK.
- In the IIS Web Site section, click Use an existing IIS Web site.
- Select Default Web Site.
- Leave the rest of the default values, and then click OK.

Work with Visual Studio 2008

BizTalk 2009 is fully integrated to Visual Studio 2008. To start with BizTalk project, you can open Visual Studio 2008 and create BizTalk empty project. All BizTalk project (Schema, Map, Pipeline, and Orchestration) will be compiled as .NET Assembly (DLL).

I will not discuss about BizTalk development here, only to give you starting point on BizTalk 2009 and Visual Studio 2008. BizTalk Development tools provides Visual Studio templates and visual designers to enable developer working on schemas, mapping the schemas, and doing system workflow (orchestration) and defining send/receive pipelines.

Visual designers in BizTalk are just tools to make your life easier when dealing with the BizTalk APIs.

We will discuss more about BizTalk development in my incoming postings.

Stay tuned!

Hope this helps – RAM

EWS – Exchange Web Services

risman — Sat, 21 Mar 2009 09:25:01 GMT

If you currently using legacy APIs in Exchange 2007 (CDOEX, WEBDAV, Event Sinks or Exchange OLEDB) for integration to LOB or 3rd party ISV applications, you can now try Exchange Web Services. Comparison between legacy APIs to EWS is explained here, including the Exchange 2007 Legacy API property mapping, for your migration purpose.

LOB apps that use EWS can access data store items locally or remotely by using a SOAP version 1.1 (or 1.2). EWS is deployed with client access server role. Exchange Server 2007 clients connect to the server that is running Exchange 2007 that has the Client Access server role installed in an Active Directory directory service site by using an HTTPS connection. The target Client Access server obtains the information by communicating over MAPI to the Exchange server that has the Mailbox server role installed and then sends it back to the source Client Access server. If the target mailbox is in the same Active Directory site, the Client Access server uses MAPI to communicate with the Mailbox server to obtain the information. The Client Access server then provides the data back to the client.

How It Works
When a client application requests information from the Exchange store, an XML request message that complies with the SOAP standard is created and sent to the Exchange server. When the Microsoft Exchange server receives the request, it verifies the credentials that are provided by the client and automatically parses the XML for the requested data. The server then builds a SOAP response that contains XML data that represents the requested strongly typed objects and their properties. The XML data is sent back to the client application in an HTTP response. The client application then de-serializes the XML and uses the data to reform the strongly typed objects. You can read more on about EWS architecture from here as you have to understand some additional concepts like autodiscover service, event notification, delegate access and server-to-server authorization.

What in Exchange Web Services

EWS provides the functionality to enable client applications to communicate with the Exchange server. EWS provides access to much of the same data made available through Outlook, to enable LOB applications to have functionalities like Outlook. The Exchange Web Services clients can integrate Outlook data into Line-of-Business (LOB) applications. Exchange Web Services is described by three files that are located in the EWS virtual directory:

- Services.wsdl : contract between client and server.
- Messages.xsd : request and response SOAP messages.
- Types.xsd : elements used in the SOAP messages.

Exchange Web Services provides the following types of operations:
- Availability
- Messaging Records Management
- Folder
- Item
- Utility
- Notification
- Synchronization

How to Start

You can download TechReady 2007 EWS Sample Codes to get started with EWS. Extract the installer then open EWSDemos.sln using Visual Studio 2005/2008. It will be better to use VS 2008 and .NET 3.5 as you can utilize new features like LINQ in your codes. To change the target WS from contoso.com, you can delete the existing WS proxy and add the new proxy based on your configuration.

Then you can start to explore the following demo applications:

- Auto Discovery Demo
- Availability Demo
- Create Meeting and Send Invitation Demo
- Pull Notification Demo

Hope this helps!

Cheers – RAM

Whats New from MIX 09

risman — Sat, 21 Mar 2009 04:43:48 GMT

MIX 09 just ended yesterday. This is the biggest web developer event from Microsoft this year. With 129 total sessions, this event brought new technologies like Silverlight 3.0, IIS 7.0 Media Services, ASP.NET MVC, IE 8, SQL Data Services (Astoria), Azure Service Platform, PHP on Windows, etc. I really suggest you to go the MIX 09 site and get all those technologies on your machine by clicking the picture below. You can click each session title then download all recorded videos and PPTs. Enjoy!.

Cheers – RAM

Learn SQL Server 2008 from Videos

risman — Mon, 16 Mar 2009 16:51:08 GMT

This post contains collection of FREE SQL Server 2005/2008 video resources.

Basic SQL Server Knowledge
- SQL Server 2005 Express for Beginner (Applicable for 2008 too)
- SQL Server How do I Videos from Technet – You can subscribe it its RSS feed
- SQL Server and Business Intelligent in Channel9
- SQL Server Events and Webcasts

More Advanced SQL Server 2008 Topics – from PDC 2008
- Deep Dive into Spatial Data
- Developing Large Scale Web Applications and Services
- Enabling Developers To Go Beyond Relational
- New and Future T-SQL Programmability
- Developing Secure Applications
- Tips and Tricks for High-Throughput Data-Driven Applications
- Business Intelligence and Data Visualization
- SQL Server 2008 for Developers
- SQL Server Compact: Embedding in Desktop and Device Applications

Totally there were 16 SQL Server 2008 and 8 SQL Server Data Services sessions in PDC 2008, you can download all slides and recorded videos from here. If you know more links, please put as comments in this post so other members can benefited.

Hope this helps - RAM

Using SSIS with MySQL

risman — Mon, 16 Mar 2009 13:31:56 GMT

This is a step by step guide for you to connect to MySQL and do SSIS data flow task to transfer data from/to SQL Server, or other RDBMS. You need SQL Server 2005/2008 with SSIS (SQL Server Integration Services) and BI development studio installed. Then install .NET Connector for MySQL, which is a standardize ADO.NET data provider for .NET.

1. Open Visual Studio and Create BI project – Integration Services Project
2. Add new data source for your MySQL (this can be data flow sources or destination)
3. Choose MySQL Data Provider (this is not ODBC) and configure/test your connection.

4. Configure your connection, pooling, security and some advanced properties.

5. Once your data source ready, now you can start to doing the SSIS package, for example Data flow task to transfer data from/to MySQL Database.

Hope this helps – RAM

PHP Interop via RESTful .NET Services

risman — Sun, 15 Mar 2009 04:13:05 GMT

RESTful Web Services gains many attentions from web developers. As REST is an architectural style, it is not tied to one particular platform and technology. In .NET platform, we can play with “RESTful Services” with WCF 3.5 REST Starter Kit, ADO.NET Data Services, and Azure Service Platform. I found the following article and resource very useful for us to understand RESTful Services in .NET platform. You can also consult to some recommended books that I listed below.

A Guide to Designing and Building RESTful Web Services with WCF 3.5
Microsoft PDC 2008 Website – A lot of Azure and SQL Data Services info

With the advance of RESTful .NET, many other Web 2.0 framework like PHP will be benefited. For example, we can easily publish data services using ADO.NET Data Services, Entity Data Model and LINQ, hosted as HTTP services in IIS then consumed by PHP applications. With REST support in popular Zend framework and WSF/PHP, this “via REST interop” can help huge numbers of PHP developers to take advantages from RESTful innovations in .NET.

Stay tuned, I will dive deeper into this PHP interop journey!

Hope this helps – RAM

Web Slice and Feed Authentication

risman — Sun, 15 Mar 2009 01:40:21 GMT

IE8 Gallery provides many Web Slice add-on that you may want to try. In this post, I will share about authentication feature in IE8 WebSlice. In many scenarios, for instance Banking application, authentication is required. The IE8 Windows RSS Platform now has support for HTTPS BASIC and HTTP/S DIGEST authentication. This option is the only supported option for setting credentials for a feed or Web Slice via our new RSS authentication APIs, right click on the WebSlice and go to its property form.

Other authentication schemes Kerberos and NTLM for example should typically ‘just work’ as the OS will already handle these schemes and users will already be authenticated to these servers (e.g. by joining a computer to a domain over NTLM) and will only access those WebSlices or feeds when within that realm.

Depends to our application requirements, each of the option has benefits and tradeoffs. We can also do the following authentication mechanisms in WebSlice:

1. Persistent login cookies (“remember me”)
2. Web Slice specific auth cookie
3. Unique subscription URLs

I’m still looking my free time to look deeper on those concepts for PHP applications, as each application has different authentication mechanism. For now, you can try to read Amy Placzkiewicz blog post in IE8 team blog:

WebSlice and Feed Authentication – Developer Guidelines

Hope this helps - RAM

Pattern and Practice Resources

risman — Sun, 15 Mar 2009 00:00:41 GMT

Many of you maybe already know the Pattern and Practice materials from Microsoft. It covers many architectural guides and best practices, including some reference architectural packs and reusable libraries. The famous reusable libraries are that I have used before are:

- Enterprise Library
- Smart Client Guidance
- Composite WPF and Silverlight
- Unity Application Block
- Web Client Software Factory
- Sharepoint Guidance

and many more….!

On top of it, my friend Mike Walker has put a collections of links, which is great resource for you if you are doing architecture. Enjoy!

Guides

Performance

Books / Guides

Methods

Guidelines

Checklists

Practices at a Glance

Performance Practices at a Glance

How Tos

Security

Guides

Methods

Threats and Countermeasures

Cheat Sheets

Guidelines

Checklists

Practices at a Glance

Questions and Answers

Explained

Application Scenarios

ASP.NET Security How Tos

WCF Security How Tos

Visual Studio Team System

Guides

Team Development with Visual Studio Team Foundation Server

Guidelines

Practices at a Glance

Questions and Answers

Source Control Practices at a Glance

How Tos

Hope this helps – RAM

Adding WebSlice in WordPress Site

risman — Sat, 14 Mar 2009 11:39:00 GMT

IE8 WebSlices are portions of a webpage that you can subscribe to and view updates directly from the Favorites bar. You can view the changes without having to go back to the site. When a website supports WebSlice, the purple WebSlice icon appears in the Commandbar of your IE 8. WebSlices also appear when you are hovering over a WebSlice region within a webpage. Here is an example from Kaskus, the largest online community in Indonesia.

When you click the Kaskus WebSlice icon, you can add it to your favorite bar, then you can see the subscribed contents from favorite bar. Another great example of WebSlice and other IE 8 features also available in eBay, http://ie8.ebay.com/.

Actually it is easy to enable WebSlice in a site, we just need to add HTML annotations to the webpage, for example:

<div class="hslice" id="kaskusitem555">
       <p class="entry-title">Kaskus Hottest Thread</p>
       <div class="entry-content">Kaskus Thread
       …
      </div>
</div>

A WebSlice uses a combination of the hAtom Microformat and the WebSlice format. By adding those three annotations, IE recognizes that it is a WebSlice and treats it like a feed; handling the discovery, subscription, and processing of the WebSlice. If you read the WebSlice format specification, you can also add additional properties to a WebSlice, such as expiration, time-to-live value, bandwidth info, revision and an alternative source.

In this post, I will show you how to add A WebSlice in common PHP applications : Wordpress. You can also do the same experiment with other CMS like Joomla, Mambo, Drupal, PHPNuke, PHPBB etc. I used IIS 7.0, PHP FastCGI and MySQL in Windows Server 2008 to run WordPress. You can follow links below if you want to have “step-by-step” to setup WordPress.

- Setting up FastCGI for PHP on IIS
- Setting up WordPress in IIS

Please put as comment if you have problem in doing the installations. Once WordPress installed and configured in your machine, you are ready to adding WebSlice. Practically, what we will do is pretty simple:

- Modify the target page where we want to display the WebSlice icon, could be index.php or other landing pages.
- Prepare a page to be displayed in the WebSlice. We can use additional css to manage the layout of the page.

WebSlice in WordPress

Create two files wp_webslice.css for WebSlice layout and for wp_webslice.php data feed at the root directory of WordPress installation. Then add the following codes to index.php :

<div id="wpupdate" class="hslice" style="padding:8px 0px 0px;display:block">
    <div style="display:none;">
        <p class="entry-title">Risman Adnan WebSlice</p>

        <p class="entry-content">&nbsp;</p>
        <a href="wp_webslice.php" class="feedurl" rel="feedurl">&nbsp;</a>
    </div>
</div>

In the wp_webslice.css, write style to manage the layout of the WebSlice.

body {
    margin:0;
    padding:0;
    font-family: Georgia, Times, Times New Roman, sans-serif;
    font-size: 0.9em;
    text-align:left;
    color:#29303B;
    background: #FEFFA3;
}

ul {
padding-left: 9px;
margin-left: 0;
}

li {
    padding-left: 0px;
    margin-left: 0px;
    margin-bottom: 10px;
}

And in the wp_webslice.php, write PHP codes to query data from tablepost then display it in the WebSlice page. For example:

<?php
/* Don't remove this line. */
require('./wp-blog-header.php');
?>

<head>
    <title>Risman Adnan Webslice</title>
    <link rel="stylesheet" type="text/css" href="wp_webslice.css" media="screen" />
    <link rel="shortcut icon" href="icon.ico" />
</head>

<body>

<div id="wpupdate" class="hslice">
<h2 class="entry-title">Risman Adnan Blogs Update</h2>
<div class="entry-content">
<ul>

<?php

    function get_recent_posts ($num_posts = 5)
    {
    global $wpdb, $tableposts, $post, $tablepost2cat;

    if (!isset($tablepost2cat)) $tablepost2cat = $wpdb->post2cat;
     if (!isset($tableposts)) $tableposts = $wpdb->posts;

    $orderby = "$tableposts.post_$orderby";

    $now = current_time('mysql');
    $sql = "SELECT DISTINCT * FROM $tableposts ";
    $sql .= "WHERE $tableposts.post_date <= '$now' AND ( $tableposts.post_status = 'publish') ";
    $sql .= "GROUP BY $tableposts.ID ORDER BY $tableposts.post_date DESC";
    $sql .= " LIMIT 0, $num_posts";

    $posts = array();
    $posts = $wpdb->get_results($sql);
    if (empty($posts)) return;

    echo '<ul>';

    foreach ($posts as $post) {

     $title = the_title('', '', false);
     echo '<li>';
     echo '<a href="'.get_permalink().'" title="View Post '.htmlspecialchars(strip_tags($title)).'">'.$title.'</a>';
     echo '</li>';
    }

    echo '</ul>';

   } //end function get_recent_posts()

   get_recent_posts();
   ?>
   </ul>
   </li>   
</div></div>

</body>
</html>

And you are done! If everything works well, you will see the WebSlice icon when you open index.php.

If you get the same result, then you are done your first WebSlice using WordPress. What about Joomla? Mambo? PHPNuke? PHPBB? I will show you later.

Hope this helps!

Cheers – RAM

Creating PHP Extension with VC++ 2008

risman — Sun, 08 Mar 2009 12:28:13 GMT

If you like C++ and want to work to create your own PHP extension, I wrote the following articles around mid June 2008 to help you:

Compiling PHP Source Codes
Part 1 : Writing PHP Extension
Part 2 : Writing PHP Extension

I also wrote one article about building the PHPSOAP extension here. You can use all of those articles as introduction to create your first PHP extension.

A lot of cool things we can do if you know how to write PHP extension on Windows. Something like PHP Extension for Sharepoint, PHP Extension for .NET Services, SQL Services and Live Services in Azure Service Platform would be very interesting. You can use both VS 2008 or VC++ 2008 Express edition.

Hope this helps - RAM

ADO.NET Data Service Part 2

risman — Sun, 08 Mar 2009 06:09:22 GMT

In this post, I will show you how to create ADO.NET Data Service from database using Entity Data Model. I will use WordPress database in MySQL 5.1. as example but you can follow with other database like SQL Server or Oracle. To install Wordpress with MySQL and IIS 7.0, you can follow this article. I will assume you already have WordPress installed in your machine. You will need .NET Connector for MySQL, I use .NET connector version 6 that is well integrated to Visual Studio.

1. Create Database Connection to WordPress DB in MySQL

We will add connection to the following database in MySQL.

Open Visual Studio 2008, in server explorer, add new data connection. Once you installed the .NET Connector, you can see option to connect to MySQL data provider as following. Then you have to provide some logon information as following.

2. Create a Entity Data Model

Create a ASP.NET Web Application in VS 2008 and add new Entity Data Model, let say WordPressDB.edmx. In the EDM Wizard, choose to generate from database and select your data connection that created in step 1.

Make sure you got all of the WordPress tables, but you dont have to select all, you can select for example only wp_users table.

Visual Studio 2008 SP1 will create the data model base on your selected table then generate data source class for your ADO.NET Data Services.

3. Create ADO.NET Data Services

In this step you have to add new item – ADO.NET Data Services called WPUsers.svc and modify its data source according to your generated entity class name:

using System;
using System.Collections.Generic;
using System.Data.Services;
using System.Linq;
using System.ServiceModel.Web;
using System.Web;

namespace Astoria
{
    public class WPUsers : DataService<WPEntities>
    {
        // This method is called only once to initialize service-wide policies.
        public static void InitializeService(IDataServiceConfiguration config)
        {
            config.SetEntitySetAccessRule("*", EntitySetRights.AllRead);
        }
    }
}

Now your ADO.NET Data Services is ready. You can test it using the REST query for example: http://localhost:12519/WPUsers.svc/:

Done, now you are ready to learn how to consume the REST based ADO.NET Data Services. I will show you in my next post.

Cheers - RAM

ADO.NET Data Service Part 1

risman — Sun, 08 Mar 2009 04:13:05 GMT

ADO.NET Data Service (previously codename Astoria) is already released in .NET 3.5 SP1. What is that actually? Its a way to convey your data in the style of REST resources addressable by URIs. Data is structured as entities and relationships according to the specifications of the Entity Data Model (EDM). It uses uniform patterns of data representation and transport, such as JSON and AtomPub. Consumer applications interact with ADO.NET Data Services by using HTTP verbs such as GET, PUT, POST, or DELETE. In many application scenarios, both online and offline data services is required, especially in our movement to cloud in low bandwidth condition like in Asia.

"ADO.NET Data Service / Astoria Offline capability" is designed to provide solution for offline requirement that use data from data services. It is ready for initial release (Alpha only for preview), where we can learn how to create offline-capable applications that have a local replica of their data, how to synchronize that replica with an online data service when a network connection becomes available, and how replicas can be used with the ADO.NET Entity Framework. Nice!

In this post, you will learn how to create ADO.NET Data Services. A lot of learning resource over here at MSDN, also in Channel9 and Microsoft PDC sites, but I hope this post can help you to accelerate your first experiment.

1. Prepare your database, let say AdventureWorks
2. Create ASP.NET Web Application – then add new item ADO.NET Data Services - FirstSvc

3. Review the generated codes for ADO.NET Data Services and add in memory data source class

using System;
using System.Collections.Generic;
using System.Data.Services;
using System.Linq;
using System.ServiceModel.Web;
using System.Web;

namespace Astoria
{
    public class FirstSvc : DataService< /* TODO: put your data source class name here */ >
    {
        // This method is called only once to initialize service-wide policies.
        public static void InitializeService(IDataServiceConfiguration config)
        {
            // TODO: set rules to indicate which entity sets and service operations are visible, updatable, etc.
            // Examples:
            // config.SetEntitySetAccessRule("MyEntityset", EntitySetRights.AllRead);
            // config.SetServiceOperationAccessRule("MyServiceOperation", ServiceOperationRights.All);
        }
    }
}

If you see the codes, intuitively, what we have to do is to prepare our data source class and set the entity set and service operation access rules. Very simple! Now, lets create a simple in memory data source, later we can use ADO.NET Entity Data Model (EDM). What we will create is a simple class contains two list of product and category, and IQueryable properties for both product and category.

public class Product 
{
    public int ID {get;set;}
    public string Name {get;set;}
    public string Color {get;set;}
    public Category ProductCategory {get;set;}
}

public class Category 
{
   public int ID {get;set;}
   public string Name {get;set;}
}

public class AstoriaData 
{
    static List<Category> categories;
    static List<Product> products;

    static AstoriaData()
    {
        categories = new List<Category>(){
            new Category {ID=1, Name = "Bikes"},
            new Category {ID=2, Name = "Bikes"}
        };

        products = new List<Product>(){
            new Product {ID=1, Name = "Red Bikers", Color="Red", ProductCategory=categories[0]},
            new Product {ID=2, Name = "Blue Bikers", Color="Blue", ProductCategory=categories[0]},
            new Product {ID=3, Name = "Green Bikers", Color="Green", ProductCategory=categories[0]}
        };
    }

    public IQueryable<Category> Categories
    {
        get {return categories.AsQueryable();}
    }

    public IQueryable<Product> Products
    {
        get {return products.AsQueryable();}
    }

}

5. Add Data Source Class

Modify your FirstSvc class to add the AstoriaData class as data source and set its access, * means give access to all entities. Your codes should be like this:

public class FirstSvc : DataService<AstoriaData>
{
    public static void InitializeService(IDataServiceConfiguration config)
    {
        config.SetEntitySetAccessRule("*", EntitySetRights.AllRead);
    }
}

5. Test Your ADO.NET Data Services in the browser

Below is your service entry point contains two entity set or collections in ATOM form,

Try the following REST queries :

http://localhost:12519/FirstSvc.svc/Products
http://localhost:12519/FirstSvc.svc/Categories
http://localhost:12519/FirstSvc.svc/Products(1)/Name
http://localhost:12519/FirstSvc.svc/Products(1)/Color
http://localhost:12519/FirstSvc.svc/Products(1)/Name/$value
http://localhost:12519/FirstSvc.svc/Products(1)/Color/$value

You are done with the in memory data source now. What else? Of course you can use your database storage like SQL Server or SQL Express. If you use Entity Data Model, you can also access other database for example MySQL. We will discuss that in the next ADO.NET Services post.

Cheers – Risman Adnan

New Updates on Azure

risman — Sat, 14 Feb 2009 05:54:55 GMT

We just released an updated version of the Azure Services Training Kit. The first Azure Services Training Kit was released during the week of PDC October 2008 and it contained all of the PDC hands-on labs. The Azure Services Training Kit February update now includes the following content covering Windows Azure, .NET Services, SQL Services, and Live Services:

- 13 hands-on labs – Including 3 new hands-on labs for the Live Framework & Services
- 19 new demo scripts – Detailed walkthroughs of key features so that someone can easily give a demo of a service
- 10 new scripted presentations – The presentations can be used for 3 day training workshops

All of this content is available as an installable package on the Microsoft Download Center. What else? In this page you will find webcasts and how-to videos covering the technologies included in the Azure Services Platform: Windows Azure, .NET Services, SQL Data Services, and Live Services. Its FREE!

Azure will be introduced in Web Ramp Up – event in Philippines, Feb 26. Stay tuned!.

Hope this helps - RAM