How does it work?

CORBA is language agnostic because it relies on its own language: the Interface Definition Language (IDL for short). The IDL defines the contract between the client (software calling the service) and the server (software implementing the service). The service is exposed through a remote object.

IDL is used to define:

• modules, which are called namespaces in C++ (or packages in Java)
• structs, which are like C structs: they can contain data only (the data part of the contract)
• interfaces, which contain methods specification (the service part of the contract)
• exceptions that can be raised by a method
• typedefs which are type aliases
• unions, à la C
• enums, enumerations
• constants

IDL comes with existing types:

• char, octet
• string, wstring
• short, long, long long (signed if unspecified, unsigned if prefixed with unsigned)
• float, double, long double
• arrays
• sequences
• any which can be any existing or user-defined type

From this contract, the following code will be generated using a dedicated tool:

• client-side code, called stubs
• server-side code, called skeletons

So to call a CORBA remote service in a given programming language, we will generate stubs from the IDL, then write code relying on these stubs. To provide a CORBA service in a given progamming language, we will generate skeletons from the IDL, then extend them with our implementation.

The dispatching and networking machinery is handled by the Object Request Broker (ORB for short). That's the most important part of the CORBA system: it's the component that hides away remoting aspects to make distant objects appear as if they were embedded within the local, client-side code.

Telecom Log Service example

The Telecom Log Service [TLOG] is an OMG specified service that defines two interfaces:

• Log, to add, search and delete records
• LogMgr, a Log container to lookup a given log, or list all contained logs

The specification details five sub-interfaces of the log service, grouped into three different approaches:

• basic implementation. This is the service depicted below.
• event-based implementation. The Event Service [EVENT] is another CORBA service specification. Combining both services means that software emitting events can be plugged to an Event Log without modification.
• notify-based implementation. The Notification Service [NOTIF] is another CORBA service specification, built on top of the Event Service, with added filtering facility. Again, combining these two services provide easier integration with existing software.

Here is the UML representation of key base interfaces (in yellow), basic implementation (in blue) and important date structures (in green):

Here is the simplified IDL for these parts:

#include <TimeBase.idl>  // IDL can include each other
#pragma prefix "omg.org" // extra prefix to use in front of type names

// DsLogAdmin definition
// Because of the #pragma prefix above, the complete name of this module
// is omg.org/DsLogAdmin
module DsLogAdmin
{
        // E X C E P T I O N --------------------------------------------------
        exception InvalidGrammar {};                    // empty exception
        exception InvalidConstraint {};                 // empty exception
        exception LogFull { short n_records_written; }; // one attribute
        exception LogOffDuty {};                        // empty exception
        exception LogLocked {};                         // empty exception
        exception LogDisabled {};                       // empty exception

        // T Y P E   A L I A S ------------------------------------------------
        typedef unsigned long LogId;
        typedef sequence<LogId> LogIdList; // LogIdList is a sequence of LogId
        typedef unsigned long long RecordId;
        typedef string Constraint;
        typedef TimeBase::TimeT TimeT; // TimeT type defined in TimeBase module
        typedef sequence<any> Anys;    // Anys is the name of a sequence of any

        // S T R U C T U R E S ------------------------------------------------
        struct NVPair {
                string name;
                any    value;
        }; // <-- Mandatory semi-colon
        typedef sequence<NVPair> NVList; // Give a name to a sequence of NVPair

        struct LogRecord {
                RecordId id;
                TimeT    time;
                NVList   attr_list;
                any      info;
        };
        typedef sequence<LogRecord> RecordList;

        // I N T E R F A C E S ------------------------------------------------
        // Iterator interface specification
        interface Iterator {
                // get() method:
                // - two input parameters
                // - returning a list of LogRecord
                // - possibly raising InvalidParam exception
                RecordList get(in  unsigned long position,
                               in  unsigned long how_many)
                        raises (InvalidParam);
                void destroy();
        };  // <-- Mandatory semi-colon

        // Forward declaration
        interface LogMgr;

        interface Log
        {
                LogMgr my_factory();

                LogId id();

                // retrieve() method:
                // - two input parameters
                // - one output parameter
                // - returning a list of LogRecord
                // This method will actually return two objects: the
                // RecordList and the Iterator
                RecordList retrieve(in  TimeT from_time,
                                    in  long how_many,
                                    out Iterator i);

                RecordList query(in  string grammar,
                                 in  Constraint c,
                                 out Iterator i)
                        raises (InvalidGrammar, InvalidConstraint);

                unsigned long delete_records(in  string grammar,
                                             in  Constraint c)
                        raises (InvalidGrammar, InvalidConstraint);

                void write_records(in  Anys records) 
                        raises (LogFull, LogOffDuty, LogLocked, LogDisabled);
        };
        typedef sequence<Log> LogList; // Give name LogList to sequence of Log

        // inteface BasicLog derives from interface Log
        interface BasicLog : Log {
                void destroy();
        };

        interface LogMgr
        {
                LogList list_logs();
                Log find_log(in LogId id);
                LogIdList list_logs_by_id();
        };

        // inteface BasicLogFactory derives from interface LogMgr
        interface BasicLogFactory : LogMgr
        {
                BasicLog create(
                        in  LogFullActionType full_action,
                        in  unsigned long long max_size,
                        out LogId id)
                        raises (InvalidLogFullAction);

                BasicLog create_with_id(
                        in  LogId id,
                        in  LogFullActionType full_action,
                        in  unsigned long long max_size)
                        raises (LogIdAlreadyExists, InvalidLogFullAction);
        };
}; // <-- Mandatory semi-colon

The complete IDL file for the Basic Telecom Log Service is available here.

We recently converted Debian ACE+TAO package repository from Subversion to git.

This was a long and interesting process; I learned a lot on git in the course. I had been using git for a while for other packages: BOUML, dwarves and GNU Smalltalk. But I did not really get it.

A preliminary study led by Pau[1] showed that out of the following three tools:

• git-svn
• nirvdrum's svn2git
• KDE svn2git[2]

the last one was giving results that look better.

svn-all-fast-export --identity-map authors.txt --rules pkg-ace.rules svn-pkg-ace

create repository pkg-ace
end repository

match /trunk/
  repository pkg-ace
  branch master
end match

match /(branches|tags)/([^/]+)/
  repository pkg-ace
  branch \2
end match

markos = Konstantinos Margaritis <email-hidden>
mbrudka-guest = Marek Brudka <email-hidden>
pgquiles-guest = Pau Garcia i Quiles <email-hidden>
tgg = Thomas Girard <email-hidden>
tgg-guest = Thomas Girard <email-hidden>

#!/usr/bin/env ruby
#
# retag.rb
#
# Small script to create an annotated tag, specifying commiter as well as
# date, and tag comment.
#
# Based on Scott Chacon "Custom Importer" example.
#
# Arguments:
#  $1 -- tag name
#  $2 -- sha-1 revision to tag
#  $3 -- committer in the form First Last <email>
#  $4 -- date to use in the form YYYY/MM/DD_HH:MM:SS

def help
  puts "Usage: retag <tag> <sha1sum> <committer> <date> <comment>"
  puts "Creates a annotated tag with name <tag> for commit <sha1sum>, using "
  puts "given <committer>, <date> and <comment>"
  puts "The output should be piped to git fast-import"
end

def to_date(datetime)
  (date, time) = datetime.split('_')
  (year, month, day) = date.split('/')
  (hour, minute, second) = time.split(':')
  return Time.local(year, month, day, hour, minute, second).to_i
end

def generate_tag(tag, sha1hash, committer, date, message)
  puts "tag #{tag}"
  puts "from #{sha1hash}"
  puts "tagger #{committer} #{date} +0000"
  print "data #{message.size}\n#{message}"
end

if ARGV.length != 5
  help
  exit 1
else
  (tag, sha1sum, committer, date, message) = ARGV
  generate_tag(tag, sha1sum, committer, to_date(date), message)
end

me@mymachine$ echo 6a6d48814d0746fa4c9f6869bd8d5c3bc3af8242 11cf74d4aa996ffed7c07157fe0780ec2224c73e 898ad49b61d4d8d5dc4072351037e2c8ade1ab68 >> .git/info/grafts

#!/bin/sh

br="HEAD"

TARG_NAME="Raphael Bossek"
TARG_EMAIL="hidden"
export TARG_NAME TARG_EMAIL

filt='

    if test "$GIT_COMMIT" = 546db1966133737930350a098057c4d563b1acdf -o \
            "$GIT_COMMIT" = 23419dde50662852cfbd2edde9468beb29a9ddcc; then
        if test -n "$TARG_EMAIL"; then
            GIT_AUTHOR_EMAIL="$TARG_EMAIL"
            export GIT_AUTHOR_EMAIL
        else
            unset GIT_AUTHOR_EMAIL
        fi
        if test -n "$TARG_NAME"; then
            GIT_AUTHOR_NAME="$TARG_NAME"
            export GIT_AUTHOR_NAME
        else
            unset GIT_AUTHOR_NAME
        fi
    fi

'

git filter-branch $force --tag-name-filter cat --env-filter "$filt" -- $br