A great software company culture
Posted on: May 14, 2013
Generally, I don’t write about anything else except the technical stuffs until unless I am impressed with, which has a factual value on our work or livelihood. This time I am going to write the things which really fascinated me more and hence can’t resist myself without sharing.
We, all, distinguish that Individuals in a corporate (here I specially mean software company), who want to make their career path in a different angle, always try to be inventive, creative and self-motivated. To know the easiest and effective way of achieving these qualities, sometimes we study huge books, articles and blogs as well as attend to the seminar which is in a sense good and certainly it also makes a good impact on us. But is this the only or right way to be innovative or is this the good pathway to make a vision for mission?
Well, company culture also plays the vital role for the novelty. A great software company culture, which has proper mentors to guide us in the right direction as well as has a good learning environment from which we can easily learn a lot not only our technical stuffs but also the things that we need in our daily lives, can give us the space to share and put our ideas without any hesitation whatever the ideas are. Think of this way, we usually spend almost 8-9 hours a day in our office, and if the office structure is not well enough, we might not feel comfort to work or to stay there for a longer period of time. And if the people, we are working with, are not matured and logical enough how do we expect good ideas from them or share our views to them. In fact, those types of people (who are not matured and logical enough) do not have such personality to provide values of our thoughts as well as concepts, besides they can put us in frustration over our capabilities. If we continue with such folks, over the period of time we might go to dust. At the same time, if we are very much engaged with our work without involving in other fun activities (playing tournament, treats, gossiping…), we might be bored at work, and in this situation, we should never presume that our brain will deliver good things. So, I think in a good custom software company, there must have a well decorated office related to the work, way of entertainment, good mentors and cool environment to learn and to teach so that we, all, one day shall be good assets for us and for the company as well which eventually leads to increase the productivity.
Fortunately, I have got the opportunity and have been working in such a cool and attractive environment where I spend each and every day by learning at least a single new thing by following the way of problems solving tactics and the approach to face complex difficulties of our mentors which ultimately have changed my way of problem solving skills and strategies. I think you have already caught up in which company I am working currently, yes this is KAZ Software. You will get an idea about how much fun we do while we are at our office if you go through our company website mainly in company & culture section.
- In: C# | Technical | WCF
- 2 Comments
Though Performance blocking and Sluggishness are the tailbacks for any application, we can easily overcome these bottlenecks by using asynchronous programming. But old-style practice for asynchronous programming is not way easy enough to write, debug and maintain. So what is the contemporary approach??
Well, In my view, this is Task based asynchronous programming, which is updated in .Net 4.5 through the use of keywords await and async. But what does async and await do? async and await is the way of controlling continuation. When a method uses the async keyword, it means it is an asynchronous method, which might has a await keyword inside, and if it has a await keyword, async will activate it. So, simply async activates the await, from which point, the asynchronous has been started. There is a nice explanation has been given here.
In WCF we can also consider an asynchronous operation while the service operation creates a delaying call. There are three ways to implement asynchronous operations
- Task-based asynchronous
- Event-based asynchronous
- IAsyncResult asynchronous
In this post I am gonna to use task-based asynchronous operation since this is the most contemporary strategy.
Okay. Let’s move to the code portion,
A very simple Service contract such as,
[ServiceContract]
public interface IMessage
{
[OperationContract]
Task<string> GetMessages(string msg);
}
With this simple contract, the implementation is just straight forward,
public class MessageService : IMessage
{
async Task<string> IMessage.GetMessages(string msg)
{
var task = Task.Factory.StartNew(() =>
{
Thread.Sleep(10000);
return “Return from Server : ” + msg;
});
return await task.ConfigureAwait(false);
}}
Here, the method is marked with the async keyword, which means it might use await keyword inside. It also means that the method will be able to suspend and then resume asynchronously at await points. Moreover, it points the compiler to boost the outcome of the method or any exceptions that may happen into the return type.
Service hosting,
class Program
{
static void Main(string[] args)
{
var svcHost = new ServiceHost(typeof (MessageService));
Console.WriteLine("Available Endpoints :\n");
svcHost.Description.Endpoints.ToList().ForEach(endpoints=> Console.WriteLine(endpoints.Address.ToString()));
svcHost.Open();
Console.ReadLine();
}
}
Finally Service Configuration,
<?xml version="1.0"?>
<configuration>
<system.serviceModel>
<services>
<service name="Rashim.RND.WCF.Asynchronous.ServiceImplementation.MessageService">
<host>
<baseAddresses>
<add baseAddress="net.Tcp://localhost:8732/"/>
<add baseAddress="http://localhost:8889/"/>
</baseAddresses>
</host>
<endpoint address="Tcp" binding="netTcpBinding" contract="Rashim.RND.WCF.Asynchronous.Services.IMessage"/>
<endpoint address="Http" binding="basicHttpBinding" contract="Rashim.RND.WCF.Asynchronous.Services.IMessage">
<identity>
<dns value="localhost"/>
</identity>
</endpoint>
<endpoint address="mex" binding="mexTcpBinding" contract="IMetadataExchange"/>
<endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange"/>
</service>
</services>
<behaviors>
<serviceBehaviors>
<behavior>
<serviceMetadata/>
</behavior>
</serviceBehaviors>
</behaviors>
</system.serviceModel>
<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5"/></startup></configuration>
After Configuring the service,we need to configure the client app to consume the service.
A simple Console Application(Client),
class Program
{
static void Main(string[] args)
{
GetResult();
Console.ReadLine();
}
private async static void GetResult()
{
var client = new Proxy("BasicHttpBinding_IMessage");
var task = Task.Factory.StartNew(() => client.GetMessages("Hello"));
var str = await task;
str.ContinueWith(e =>
{
if (e.IsCompleted)
{
Console.WriteLine(str.Result);
}
});
Console.WriteLine("Waiting for the result");
}
}
Client Configuration,
<?xml version="1.0"?>
<configuration>
<system.serviceModel>
<bindings>
<basicHttpBinding>
<binding name="BasicHttpBinding_IMessage" />
</basicHttpBinding>
</bindings>
<client>
<endpoint address="http://localhost:8889/Http" binding="basicHttpBinding"
bindingConfiguration="BasicHttpBinding_IMessage" contract="Rashim.RND.WCF.Asynchronous.Services.IMessage"
name="BasicHttpBinding_IMessage" />
</client>
</system.serviceModel>
</configuration>
Finally,proxy class is given below through which the client will consume the services.
public class Proxy : ClientBase<IMessage>, IMessage
{
public Proxy()
{
}
public Proxy(string endpointConfigurationName) :
base(endpointConfigurationName)
{
}
public Task<string> GetMessages(string msg)
{
return Channel.GetMessages(msg);
}
}
That’s it. Very easy stuff though.
Duplex Service in WCF
Posted on: April 6, 2013
- In: C# | Technical | WCF
- Leave a Comment
In WCF, a service can call back to its clients. That is to say that, at the time of call back, the service behaves as a client as well as the client becomes the service, and the client must assist hosting the call back object. To support call back, the underlying transport of the binding must support bidirectional. So, for the nature of connectionless, we cannot use all bindings for the call back operation. For instance, BasicHttpBinding or WsHttpBinding does not support callback while WsDualHttpBinding supports it, because this binding establishes two HTTP channel to do that; one for client to service another for service to client. Also, NetTcpBinding and NetNamedPipeBinding supports callback since their underlying transport is bidirectional.
Callback service can be supported by using CallbackContract property in the ServiceContract attribute. Only one callback contract is allowed for a service contract. After defining a callback contract, we require to set up the client for up keeping the callback and also to offer the callback endpoint to the service for each and every call.
In the example given below, the callback contract defines the operations to which the service can call on the client endpoint
public interface INotificationServiceCallBack
{
[OperationContract(IsOneWay = true)]
void OnNotificationSend(string message);
}
The implementation of this Service Contract,
[CallbackBehavior(ConcurrencyMode = ConcurrencyMode.Reentrant)]
public class NotificationServiceCallBack : INotificationServiceCallBack
{
public void OnNotificationSend(string message)
{
Console.WriteLine(message);
Console.ReadLine();
}
}
Here CallbackBehavior refers how the callback of this operation will act which is similar to ServiceBehavior.
And the service contract has been defined like the way given below,
[ServiceContract(CallbackContract = typeof(INotificationServiceCallBack))]
public interface INotificationServices
{
[OperationContract]
void SendNotification(string message);
}
To make a way around for the service to call, clients must expose an endpoint to the service. This has been done by the following way,
public class Program
{
public static INotificationServices Proxy
{
get
{
var ctx = new InstanceContext(new NotificationServiceCallBack());
return
new DuplexChannelFactory<INotificationServices>(ctx, "WSDualHttpBinding_INotificationServices")
.CreateChannel();
}
}
static void Main(string[] args)
{
Proxy.SendNotification("Are u ready?");
Console.ReadLine();
}
}
Here InstanceContext is the execution scope of inner most service instance. It provides a constructor that takes the service instance to the host.
And now service implementation,
public class NotificationService : INotificationServices
{
public INotificationServiceCallBack Proxy
{
get { return OperationContext.Current.GetCallbackChannel<INotificationServiceCallBack>(); }
}
public void SendNotification(string message)
{
Console.WriteLine("\nClient says :"+message);
Proxy.OnNotificationSend("Yes");
}
}
In the above example, we see that the service has the proxy of INotificationServiceCallBack and call its operation which the clients will handle.
That’s it. Now the total code portion that i have used here has been given,
Services and Implementations,
public interface INotificationServiceCallBack
{
[OperationContract(IsOneWay = true)]
void OnNotificationSend(string message);
}
[ServiceContract(CallbackContract = typeof(INotificationServiceCallBack))]
public interface INotificationServices
{
[OperationContract]
void SendNotification(string message);
}
[CallbackBehavior(ConcurrencyMode = ConcurrencyMode.Reentrant)]
public class NotificationServiceCallBack : INotificationServiceCallBack
{
public void OnNotificationSend(string message)
{
Console.WriteLine(message);
Console.ReadLine();
}
}
public class NotificationService : INotificationServices
{
public INotificationServiceCallBack Proxy
{
get { return OperationContext.Current.GetCallbackChannel<INotificationServiceCallBack>(); }
}
public void SendNotification(string message)
{
Console.WriteLine("\nClient says :"+message);
Proxy.OnNotificationSend("Yes");
}
}
Server and its configuration,
class Program
{
static void Main(string[] args)
{
var svcHost = new ServiceHost(typeof(NotificationService));
svcHost.Open();
Console.WriteLine("Available Endpoints :\n");
svcHost.Description.Endpoints.ToList().ForEach(endpoint=> Console.WriteLine(endpoint.Address.ToString()));
Console.ReadLine();
svcHost.Close();
}
}
}
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.web>
<compilation debug="true" />
</system.web>
<system.serviceModel>
<services>
<service name="Rashim.RND.WCF.CallBack.Services.NotificationService">
<host>
<baseAddresses>
<add baseAddress = "net.Tcp://localhost:8732/"/>
<add baseAddress="http://localhost:8888"/>
</baseAddresses>
</host>
<endpoint address="CallbackService" binding="netTcpBinding" contract="Rashim.RND.WCF.CallBack.Interfaces.INotificationServices"/>
<endpoint address="CallbackService" binding="wsDualHttpBinding" contract="Rashim.RND.WCF.CallBack.Interfaces.INotificationServices"/>
<endpoint address="mex" binding="mexTcpBinding" contract="IMetadataExchange" />
<endpoint address="http://localhost:8888/mex" binding="mexHttpBinding" contract="IMetadataExchange" />
</service>
</services>
<behaviors>
<serviceBehaviors>
<behavior>
<serviceMetadata />
<serviceDebug includeExceptionDetailInFaults="False" />
</behavior>
</serviceBehaviors>
</behaviors>
</system.serviceModel>
</configuration>
Client and its Configuration,
public class Program
{
public static INotificationServices Proxy
{
get
{
var ctx = new InstanceContext(new NotificationServiceCallBack());
return
new DuplexChannelFactory<INotificationServices>(ctx, "WSDualHttpBinding_INotificationServices")
.CreateChannel();
}
}
static void Main(string[] args)
{
Proxy.SendNotification("Are u ready?");
Console.ReadLine();
}
}
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.serviceModel>
<client>
<endpoint address="http://localhost:8888/CallbackService" binding="wsDualHttpBinding"
contract="Rashim.RND.WCF.CallBack.Interfaces.INotificationServices" name="WSDualHttpBinding_INotificationServices">
</endpoint>
<endpoint address="net.tcp://localhost:8732/CallbackService"
binding="netTcpBinding"
contract="Rashim.RND.WCF.CallBack.Interfaces.INotificationServices" name="NetTcpBinding_INotificationServices">
</endpoint>
</client>
</system.serviceModel>
</configuration>
- In: C# | Codeproject | Technical | WCF
- 1 Comment
When working with distributed application, securing communication between the client and the service is a very vital issue. Windows Communication Foundation provides the facility of transfer security which is responsible for ensuring the integrity and confidentiality of service messages, and also responsible for providing authentication. Transfer security in WCF is achieved through the use of either transport security or message security. Transport-layer security provides integrity and confidentiality, while message-layer security provides a variety of passes which are not possible with transport security mechanisms. When using transport security, user credentials are transport-dependent, which allows fewer authentication options compared to message security. And each transport protocol has its own way for passing credentials and handling message guard. But SSL is the most common approach for encrypting and signing the contents sent over HTTPS. Here I will explain how to configure WCF Services and Clients to communicate over HTTPS by using self-signed Certificates.
When I intend to write any technical stuff, my intention always goes to start with a very simple example as well as gives an overview with the necessary things related to it. There is no difference this time as well. So for the purposes of this blog post I am going to organize it with Self-Signed Certificate Creation, Services and its Configuration, Clients and its Configuration. Please be noted that I would like to use custom binding for the code examples given here.
Self-Signed Certificate Creation
In Certificate based communication, we need to use two certificates for the client and server to authenticate each other. To make those certificates I would like to use the “MakeCert.exe” utility with the following arguments
makecert -pe -ss My -sr LocalMachine -a sha1 -sky exchange -n CN=ServerCertificate
makecert -pe -ss MY -sr LocalMachine -a sha1 -sky exchange -n CN=ClientCerttificate
The complete specification of this is available here
Now,
First bring up the Microsoft Management Console by launching mmc.exe which allows us to browse the local machine’s cache of certificates.
Next add the Certificates MMC Snap-in and select Computer account
Navigate to the “Personal” node to see ClientCertificate and ServerCertificate.
It is also required to export the certificates from the certificate store and import the copies of those into the TrustedPeople store so that WCF can find them for validation purposes.
Since I would like to use IIS hosting, we need to configure IIS for https. To do that,
- Open IIS Manager
- Select Default Web site and open its property window
- Click the Edit Binding.
Click Add and select HTTPS and then Select ServerCertificate that you have created earlier
Okay done .Everything is okay now.
Service and its Configuration
I have used here very simple service which is “Feedback” service. The service contract looks like,
[ServiceContract]
public interface IFeedback
{
[OperationContract]
string GiveFeedback(string question);
}
With such a simple contract the implementation is just straight forward
public class Feedback : IFeedback
{
public string GiveFeedback(string question)
{
var feedback = question + " : This is very funny stuff";
return feedback;
}
}
The configuration file for this Service is given below,
<configuration>
<system.web>
<compilation debug="true" targetFramework="4.0" />
</system.web>
<system.serviceModel>
<services>
<service
name="Rashim.RND.WCF.SecureCommunication.WcfService.Feedback"
behaviorConfiguration="MyCustomBehavior">
<endpoint address=""
binding="customBinding"
contract="Rashim.RND.WCF.SecureCommunication.Interfaces.IFeedback"
bindingConfiguration="MyCustomBinding"/>
<endpoint
address="mex"
binding="mexHttpsBinding"
contract="IMetadataExchange" />
</service>
</services>
<behaviors>
<serviceBehaviors>
<behavior name="MyCustomBehavior">
<serviceMetadata httpsGetEnabled="true" />
<serviceCredentials>
<clientCertificate>
<authentication
certificateValidationMode="PeerTrust"
trustedStoreLocation="LocalMachine" />
</clientCertificate>
<serviceCertificate
findValue="ServerCert"
x509FindType="FindBySubjectName"
storeLocation="LocalMachine"
storeName="My"/>
</serviceCredentials>
</behavior>
</serviceBehaviors>
</behaviors>
<bindings>
<customBinding>
<binding name="MyCustomBinding"
closeTimeout="00:20:00"
openTimeout="00:20:00"
receiveTimeout="00:20:00"
sendTimeout="00:20:00">
<security
authenticationMode="CertificateOverTransport"
requireSecurityContextCancellation="true"/>
<httpsTransport/>
</binding>
</customBinding>
</bindings>
<serviceHostingEnvironment
multipleSiteBindingsEnabled="false" />
</system.serviceModel>
<system.webServer>
<modules runAllManagedModulesForAllRequests="false" />
<directoryBrowse enabled="true" />
</system.webServer>
</configuration>
To get a better idea about the different sections of this configuration file I would like to explain it a bit more,
<services>
<service
name="Rashim.RND.WCF.SecureCommunication.WcfService.Feedback"
behaviorConfiguration="MyCustomBehavior">
<endpoint
address="" binding="customBinding"
contract="Rashim.RND.WCF.SecureCommunication.Interfaces.IFeedback"
bindingConfiguration="MyCustomBinding"/>
<endpoint address="mex"
binding="mexHttpsBinding"
contract="IMetadataExchange" />
</service>
</services>
In this above section we see that Custom behavior configuration and custom binding configuration has been used.
The custom behavior section is given below,
<behavior name="MyCustomBehavior">
<serviceMetadata httpsGetEnabled="true" />
<serviceCredentials>
<clientCertificate>
<authentication
certificateValidationMode="PeerOrChainTrust"
trustedStoreLocation="LocalMachine" />
</clientCertificate>
<serviceCertificate
findValue="ServerCert"
x509FindType="FindBySubjectName"
storeLocation="LocalMachine"
storeName="My"/>
</serviceCredentials>
</behavior>
Here clientCertificate describes an X.509 certificate which has been used to validate a client to a service. At the same time, serviceCertificate specify an X.509 certificate that will be used to authenticate the service to clients. There is a detail explanations about this has been given here [^] [^].
And the custom binding configuration section is,
<binding name="MyCustomBinding"
closeTimeout="00:20:00"
openTimeout="00:20:00"
receiveTimeout="00:20:00"
sendTimeout="00:20:00">
<security
authenticationMode="CertificateOverTransport"
requireSecurityContextCancellation="true">
</security>
<sslStreamSecurity requireClientCertificate="true"/>
<httpsTransport/>
</binding>
We know that, WCF provides several modes by which clients and services verify to each other. We can create binding for these authentication modes through configuration or by code. Here I have used CertificateOverTransport which means the service is valid using an X.509 certificate at the transport layer. And requireSecurityContextCancellation specifies whether security context should be cancelled and terminated when it is no longer required.
That’s it.Now try to browse https://localhost/Feedback/Feedback.svc and you will get the following page
Client and its Configuration
Once services have been implemented, the implementation of client is pretty simple. The client code has been given below,
System.Net.ServicePointManager.ServerCertificateValidationCallback += (se, cert, chain, sslerror) => true;
var channel = new ChannelFactory<IFeedback>(“FeedbackEndpoint”);
var client = channel.CreateChannel();
var input = Console.ReadLine();
while (input != null && input.ToLower() != “exit”)
{
var feedback = client.GiveFeedback(input);
Console.WriteLine(feedback);
input = Console.ReadLine();
}
The code above will trust any security certificate handed back from the server since it bypasses the SSL certificate validation. As the certificate I have used here is a self-signed certificate and it is not signed by a trusted CA, I need to make own validation logic to check for it .
So the configuration file for the client is,
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.serviceModel>
<bindings>
<customBinding>
<binding name="MyCustomBinding">
<security authenticationMode="CertificateOverTransport"/>
<textMessageEncoding />
<httpsTransport />
</binding>
</customBinding>
</bindings>
<behaviors>
<endpointBehaviors>
<behavior name="MyCustomBehavior">
<clientCredentials>
<clientCertificate
findValue="ClientCert"
storeLocation="LocalMachine"
storeName="My"
x509FindType="FindBySubjectName" />
<serviceCertificate>
<authentication
certificateValidationMode="PeerOrChainTrust"/>
</serviceCertificate>
</clientCredentials>
</behavior>
</endpointBehaviors>
</behaviors>
<client>
<endpoint
address="https://localhost/FeedbackService/Feedback.svc"
binding="customBinding"
bindingConfiguration="MyCustomBinding"
contract="Rashim.RND.WCF.SecureCommunication.Interfaces.IFeedback"
behaviorConfiguration="MyCustomBehavior"
name="FeedbackEndpoint"/>
</client>
</system.serviceModel>
</configuration>
That’s it. I think this would help you while you will be working with the Certificate based communication.
IIS virtual directory creation fails on IIS 7.0 / windows server 2008 using Nant build script in TeamCity
Posted on: January 7, 2013
- In: .NET | Deployment
- Leave a Comment
When I tried to create a virtual directory in the remote server using Nant build script It could not create and shows the error message below:
The webservice at 'remote_machine' does not exist or is not reachableI am afraid to say that I have spent a full working day to find out the proper solution for that and finally solved it. I hope it would help those who are facing similar kind of weird problems as well. Having said that the OS of my remote server is windows server 2008 r2 and IIS version is 7. Anyway let’s start with that,
First thing first, you need to check that you are able to connect to the remote server from IIS Manager of your local machine/current server. To do that, please follow the instructions given below.
1. Go to the IIS Manager of local machine/Current server
2. File->Connect to a Server
3. Put Remote Server name and Credentials and then try to connect
Well, Could you connect to the remote server? I suspect you might not be able also it might show a warning message like that
Okay.Lets move to fix it up. What you require to repair this issue is to enable the Management Service of remote server so that it would allow Remote Connection. For doing this you could follow this link.
Or you could follow the instructions given below,
1.Run the following command
Dism /online /enable-feature /featurename:IIS-ManagementService
2. Go to the registry editor and,
Set EnableRemoteManagement to 1
under HKEY_LOCAL_MACHINE\Software\Microsoft\WebManagement\Server
3. Finally run the command again
Net start wmsvc
Now try to connect to the remote server again from IIS Manager of your local machine/current server. This is Okay now right? 
What next….
You should run the TeamCity Build Agent under the Administrative privileges. To ensure that you need to create a domain user account and have to give it the administrative privileges and finally use this account for TeamCity Build Agent. After creating a domain user account which has a administrative privileges you need to follow the instructions,
1. Open Services Management Console
2. Stop the TeamCity Build Agent Manually
3. Select TeamCity Build Agent and go to its Properties window
4. On the Properties window, select LogOn tab.
5. Select this account(not Local system) and then put the credential
6. Start the TeamCity Build Agent
Which might look like this figure
That’s it. Try to deploy your project with TeamCity again. Problem Solved right??
WCF 4.0 Discovery
Posted on: October 4, 2012
- In: Technical | WCF
- Leave a Comment
WCF services can broadcast their availability to the network using a multicast memo or to a discovery proxy server. Client applications can pursuit the network or a discovery proxy server to discovery services that encounter a set of criteria. There are two modes of service discovery Ad-hoc Discovery and Managed Discovery. In the ad-hoc discovery clients can discover services on a local subnet and in Managed discovery clients can discover services on a larger managed network through a discovery proxy.
The easiest way to enable service discovery is through the ad hoc mode. To configure the service for discovery, we need to add the standard udpDiscoveryEndpoint endpoint as well as need to enable the serviceDiscovery behavior on the service. Once udpDiscoveryEndpoint is active, clients will be able to discover it over UDP and bind to the endpoint. If the service exposes the metadataExchange endpoint, the client can discover it too and dynamically bind to the end point.
The complete of my article about is given here.Please have a look.
WCF 4.0 Configuration Updates
Posted on: September 30, 2012
- In: .NET | Technical | WCF
- Leave a Comment
Windows Communication Foundation (WCF) is a framework for building service-oriented applications. It allows developers to configure services using configuration files or code. Though the configuration settings can be defined through code, it would be easier after being deployed for administration if we put these settings in a configuration file. But when the configuration file becomes too large, the pain comes in. Usually the WCF Configuration Schema is complex and provides user with many hard to find features. WCF 4.0 comes with new features “Simplified Configuration” to remove this pain through support for default endpoints, binding and behavior configurations. In this article I am going to introduce WCF 4.0 configuration model updates. I will explain step by step of the followings features,
- Default Endpoints
- Default Bindings
- Default Behaviors
- Standard Endpoints
- File-less Activation
You will get the total article here.
