Coversant

Register User

Eero — Mon, 27 Feb 2012 19:56:30 +0000


using (Session s = new Session(Utility.SoapBoxServer))
{
    s.OpenStreamSynchronous();

    // Send the "Get Instructions" message to the server.
    RegisterInfoRequest info = new RegisterInfoRequest(Utility.SoapBoxServerJID);
    RegisterInfoResponse Key = WConvert.ToRegisterInfoResponse(s.Send(info));

    // When we register, send in the key that was returned earlier.
    RegisterRequest register = new RegisterRequest(Utility.SoapBoxServerJID,
     newUserName.UserName, newUserPassword, Key.Key);
    s.Send(register);

    // We now have a new user! Let's dispose this session, and do a standard login.
}

using (Session s = Session.Login(newUserName.UserName, newUserPassword, newUserName.Server))
{
    // If we got this far, the user is logged in.

    // Announce Presence
    s.Send(new AvailableRequest());
}

Stream Initiation

Eero — Mon, 27 Feb 2012 19:55:41 +0000


using( Session activeSession = new Session(co) )
{
    activeSession.OpenStreamSynchronous();

    // At this point we have a stream that's open, and is not secured.
    System.Console.WriteLine("Session ID is: {0}  On Server: {1} with XMPP Domain Name: {2}",
        activeSession.SessionID,
        activeSession.ServerInformation.HostName,
        activeSession.ServerInformation.XMPPDomain);
}

Simple IQ

Eero — Mon, 27 Feb 2012 19:54:47 +0000


using (Session activeSession = Session.Login(Utility.UserName, Utility.CommonPassword, Utility.SoapBoxServer))
    {
        // Ask the server 'What Time is it?'
        TimeResponse tr = activeSession.Send(new TimeRequest()) as TimeResponse;

        // Print out the results.
        System.Console.WriteLine("The time is {0} in timezone {1}", tr.UTCDateTime,
         tr.Timezone);
    }

Private Storage

Eero — Mon, 27 Feb 2012 19:53:44 +0000


using (Session activeSession = Session.Login(Utility.UserName, Utility.CommonPassword, Utility.SoapBoxServer))
{
   //Create a new request and add some data to store into it.
   PrivateStorageRequest storageRequest = new PrivateStorageRequest();
   storageRequest.AddPackage("PrivateStorageSample", "coversant", "This is my private data")
    ;

   // Send our storage request to the server.
   activeSession.Send(storageRequest);

   // Lookup our stored data in the server.
   PrivateGetRequest storageLookup = new PrivateGetRequest("PrivateStorageSample",
    "coversant");
   PrivateGetResponse storedData = activeSession.Send(storageLookup) as PrivateGetResponse;

   Assert.IsTrue(storedData.Package.InnerText == "This is my private data", "Wrong data from
    server");
}

Rosters

Eero — Mon, 27 Feb 2012 19:52:54 +0000


using (Session activeSession = Session.Login(Utility.UserName, Utility.CommonPassword, Utility.SoapBoxServer))
{
    /*
    *      Roster Add
    */

    // Create a new user name, and prepare to add that user to our roster. This user should
    // be in the Bare JID format (user@server) and NOT in the Resource JID format
     (user@server/resource).
    JabberID userToAdd = new JabberID(Guid.NewGuid().ToString(), Utility.SoapBoxServer,
     string.Empty);

    // Create the Roster Add Packet, and Send it to the server.
    RosterAdd r = new RosterAdd(userToAdd, FriendlyUserName);
    activeSession.Send(r);

    /*
    *      Roster Get (aka: Verify the user was really Added)
    */

    // Let's pull down the roster now, and make sure that new user is really in there.
    RosterResponse currentRoster = activeSession.Send(new RosterRequest()) as
     RosterResponse;

    // The roster that we now have is going to have Roster Items in it. Let's iterate over
    // these items and find the one we just added.

    RosterItem ourUser = null;
    foreach (RosterItem ri in currentRoster.Items)
    {
        if (ri.JID.Equals(userToAdd))
        {
            ourUser = ri;
            break;
        }
    }

    Assert.IsNotNull(ourUser, "Unable to find the user we just added");
    Assert.AreEqual(ourUser.Name, FriendlyUserName, "Incorrect Friendly Name");

    /*
    *      Roster Remove
    */

    // The easiest way to remove a user is to just pass in
    // the roster item that should be removed.
    // Alternativly, we could pass in the JID and Friendly Name of the item to remove.
    RosterRemove remove = new RosterRemove(ourUser);
    activeSession.Send(remove);

    /*
    *      Roster Get (aka: Verify the user was removed)
    */
    // The User is now removed. Let's pull down the roster again and make sure.
    RosterResponse removedUserRoster = activeSession.Send(new RosterRequest()) as
     RosterResponse;
    foreach (RosterItem ri in removedUserRoster.Items)
    {
        if (ri.JID.Equals(userToAdd))
            Assert.Fail("The user that was just removed ('{0}' has been found",
             ri.JID.ToString());
    }
}

Sending Messages

Eero — Mon, 27 Feb 2012 19:45:27 +0000


using (Session activeSession = Session.Login(Utility.UserName, Utility.CommonPassword, Utility.SoapBoxServer))
{
  JabberID toUser = new JabberID("targetuser", Utility.SoapBoxServer);
  MessagePacket mp = new MessagePacket(toUser, "Subject", "Body");
  activeSession.Send(mp);
}

Presence Subscription

Eero — Mon, 27 Feb 2012 19:12:25 +0000


using (Session user2Session = Session.Login(user2.UserID.UserName, user2.Password, user2.UserID.Server))
{
    // We'll be using these to trigger on subscriptions being completed
    ManualResetEvent user1ToUser2SubscriptionComplete = new ManualResetEvent(false);
    ManualResetEvent user2ToUser1SubscriptionComplete = new ManualResetEvent(false);

    // We have now logged in both users.

    // Announce presence for both users.
    user1Session.Send(new AvailableRequest());
    user2Session.Send(new AvailableRequest());

    // We need to have both users listen for the Subscribe Packets. This is what each user
    // will receive once we ask for a presence subscription
    user1Session.AddHandler(null, typeof(SubscribeRequest), IncomingSubscribeForUser1,
     user1Session, false);
    user2Session.AddHandler(null, typeof(SubscribeRequest), IncomingSubscribeForUser2,
     user2Session, false);

    // We need to have both users listen for the Subscribed Response Packets. This is what
    // each user will receive once their subscription is approved.
    user1Session.AddHandler(null, typeof(SubscribedResponse),
     IncomingSubscribedResponseForUser1, user1ToUser2SubscriptionComplete, false);
    user2Session.AddHandler(null, typeof(SubscribedResponse),
     IncomingSubscribedResponseForUser2, user2ToUser1SubscriptionComplete, false);

    /*
    *      Start out by having User1 subscribe to User2's presence.
    *
    *      If you're not familiar with asynchronous programming, this
    *      is going to be a bit confusing.
    *
    */

    user1Session.Send(new SubscribeRequest(user2.UserID));
    if (!user1ToUser2SubscriptionComplete.WaitOne(30000, false))
        Assert.Fail("User 1 Subscribing to User 2 never completed.");

    /*
    *      Now have User2 Subscribe to User1
    */

    user2Session.Send(new SubscribeRequest(user1.UserID));
    if (!user2ToUser1SubscriptionComplete.WaitOne(30000, false))
        Assert.Fail("User 2 Subscribing to User 1 never completed.");

    /*
    * Subscriptions are now completed.
    *
    * Let's pull down the roster for each user, and make sure
    * everything is correct.
    *
    */

    RosterResponse user1Roster = user1Session.Send(new RosterRequest()) as RosterResponse;
    RosterResponse user2Roster = user2Session.Send(new RosterRequest()) as RosterResponse;

    // We now have rosters for both users. Let's check 'em.
    Assert.IsTrue(user1Roster.Items.Count == 1, "Invalid Number of items in User1 Roster");
    Assert.IsTrue(user2Roster.Items.Count == 1, "Invalid Number of items in User2 Roster");

    Assert.IsTrue(user1Roster.Items.Contains(user2.UserID),
     "User 2 is not found in user1's roster");
    Assert.IsTrue(user2Roster.Items.Contains(user1.UserID),
     "User 2 is not found in user1's roster");

    Assert.IsTrue(user1Roster.Items.Item(user2.UserID).Subscription.Equals
    ("both", StringComparison.InvariantCultureIgnoreCase),
    "Incorrect Subscription type in User1's Roster");
    Assert.IsTrue(user2Roster.Items.Item(user1.UserID).Subscription.Equals
   ("both", StringComparison.InvariantCultureIgnoreCase),
     "Incorrect Subscription type in User2's Roster");
}

Announcing Presence

Eero — Mon, 27 Feb 2012 19:08:20 +0000


using(Session activeSession = Session.Login(Utility.UserName, Utility.CommonPassword, Utility.SoapBoxServer))
{
    // At this point we're all logged into the server.

    // Create a presence packet.
    AvailableRequest Announce = new AvailableRequest(AvailableRequest.ShowValuesEnum.Normal,
     "Hello World");

    // Send it to the server
    activeSession.Send(Announce);

    // The server would now send out presence to anyone who is subscribed to my presence.
}

Coversant & Intel partnership bears fruit

Eero — Thu, 23 Feb 2012 18:44:05 +0000

Challenge

Enable new capabilities in data communication that are limited or not available through HTTP for usage areas such as command and control implementations and municipal smart grids. Key desirable features include presence checking (discovering the availability of potential communication partners) and bidirectional messaging.

Solution

By optimizing its SoapBox* Server product for scalability and performance on multicore Intel® architecture, Coversant enables solutions that deliver extremely large amounts of data using Extensible Messaging and Presence Protocol (XMPP). This open standard is designed explicitly for extensibility, supporting capabilities such as Voice over Internet Protocol (VoIP) and file transfer.

Intel – Coversant Success Story

Gartner: XMPP becoming a universal standard

Eero — Fri, 03 Dec 2010 22:36:37 +0000

XMPP (eXtensible Messaging and Presence Protocol) has been under Gartner radar for years. However, during the past months, several signs of XMPP come of age have been found in Gartner research.

At end of november 2010, David Mario Smith published a good research document explaining that he was expecting XMPP to become the universal real-time messaging protocol by 2015.

Gartner believes that, by 2015, these needs will drive the adoption of XMPP as the universal standard for near real-time communication — much as SMTP is the standard for e-mail. IT leaders in charge of collaboration and social software initiatives should learn what XMPP does, what the current state of adoption is and how to prepare for XMPP becoming the standard for interoperability and federation.

Reference documents:

MarketScope for Enterprise Instant Messaging and Presence (Restricted document)
Take Four Steps to Prepare for XMPP Becoming a Universal Standard(Restricted document)