Efficient Way to do batch import XMI in Enterprise Architect

Question

Our team are using Enterprise Architect version 10 and SVN for the repository. Because the EAP file size is quite big (e.g. 80 MB), we exports each packages into separate XMI and stored it into SVN. The EAP file itself is committed after some milestone. The problem is to synchronize the EAP file with work from co worker during development, we need to import lots of XMI (e.g. total can be 500 files).

I know that once the EAP file is updated, we can use Package Control -> Get All Latest. Therefore this problem occurs only during parallel development.

We have used keyboard shorcuts to do the import as follow:

1. Ctrl+Alt+I (Import package from XMI file)
2. Select the file name to import
3. Alt+I (Import)
4. Enter (Yes)
5. Repeat step number 2 to 4 until module finished

But still, importing hundreds of file is inefficient.

I've checked that the Control Package has Batch Import/Export. The batch import/export are working when I explicitly hard-coded the XMI Filename, but the options are not available if using version control (batch import/export options are greyed).

Is there any better ways to synchronize EAP and XMI files?

Answer 1

There is a scripting interface in EA. You might be able to automate the import using that. I've not used it but its probably quite good.

I'm not sure I fully understand your working environment, but I have some general points that may be of interest. It might be that if you use EA in a different way (especially my first point below), the need to batch import might go away.

Multiworker

First, multiple people can work on the same EAP file at a time. The EAP file is nothing more than an Access database file, and EA uses locking to stop multiple people editing the same package at the same time. But you can comfortably have multiple people editing different packages in one EAP file at the same time. Putting the EAP file on a file share somewhere is a good way of doing it.

Inbuilt Revision Control

Secondly, EA can interact directly with SVN (and other revision control systems). See this. In short, you can setup your EAP file so that individual packages (and everything below them) is SVN controlled. You can then check out an individual package, edit it, check it back in. Or indeed you can check out the whole branch below a package (including sub packages that are themselves SVN controlled).

Underneath the hood EA is importing and exporting XMI files and checking them in and out of SVN, whilst the EAP file is always the head revision. Just like what you're doing by hand, but automated. It makes sense given that you can all use the one single EAP file. You do have to be a bit careful rolling back - links originating from objects in older versions of one package might be pointing at objects that no longer exist (but you can look at the import log errors to see if this is the case). It takes a bit of getting used to, but it works pretty well.

There's also the built in package baselining functionality - that might be all you need anyway, and works quite well especially if you're all using the same EAP file.

Bigger Database Engine

Thirdly, you don't have to have an EAP file at all. The model's database can be in any suitable database system (MySQL, SQL Server, Oracle, etc). So that gives you all sorts of options for scaling up how its used, what its like over a WAN/Internet, etc.

In short Sparx have been quite sensible about how EA can be used in a multi-worker environment, and its worth exploiting that.

Answer 2

I have created the EA script using JScript for the automation

Here is the script to do the export:

!INC Local Scripts.EAConstants-JScript

/*
 * Script Name : Export List of SVN Packages
 * Author      : SDK
 * Purpose     : Export a package and all of its subpackages information related to version 
 *               controlled. The exported file then can be used to automatically import
 *               the XMIs
 * Date        : 30 July 2013
 * HOW TO USE  : 1. Select the package that you would like to export in the Project Browser
 *               2. Change the output filepath in this script if necessary.
 *                  By default it is "D:\\EAOutput.txt"
 *               3. Send the output file to your colleague who wanted to import the XMIs
 */

var f; 

function main()
{
    // UPDATE THE FOLLOWING OUTPUT FILE PATH IF NECESSARY
    var filename = "D:\\EAOutput.txt";

    var ForReading = 1, ForWriting = 2, ForAppending = 8;

    Repository.EnsureOutputVisible( "Script" );
    Repository.ClearOutput( "Script" );
    Session.Output("Start generating output...please wait...");

    var treeSelectedType = Repository.GetTreeSelectedItemType();

    switch ( treeSelectedType )
    {
        case otPackage:
        {
            var fso = new ActiveXObject("Scripting.FileSystemObject");
            f = fso.OpenTextFile(filename, ForWriting, true);

            var selectedObject as EA.Package;
            selectedObject = Repository.GetContextObject();
            reportPackage(selectedObject);
            loopChildPackages(selectedObject);

            f.Close();
            Session.Output( "Done! Check your output at " + filename);
            break;
        }
        default:
        {
            Session.Prompt( "This script does not support items of this type.", promptOK );
        }
    }
}

function loopChildPackages(thePackage)
{
    for (var j = 0 ; j < thePackage.Packages.Count; j++)
    {
        var child as EA.Package;
        child = thePackage.Packages.GetAt(j);
        reportPackage(child);
        loopChildPackages(child);
    }
}

function getParentPath(childPackage)
{
    if (childPackage.ParentID != 0)
    {
        var parentPackage as EA.Package;
        parentPackage =  Repository.GetPackageByID(childPackage.ParentID);
        return getParentPath(parentPackage) + "/" + parentPackage.Name;
    }
    return "";
}

function reportPackage(thePackage)
{
    f.WriteLine("GUID=" + thePackage.PackageGUID + ";"
                   + "NAME=" + thePackage.Name + ";" 
                   + "VCCFG=" + getVCCFG(thePackage) + ";" 
                   + "XML=" + thePackage.XMLPath + ";"
                   + "PARENT=" + getParentPath(thePackage).substring(1) + ";"
    );
}

function getVCCFG(thePackage)
{
    if (thePackage.IsVersionControlled)
    {
        var array = new Array();
        array = (thePackage.Flags).split(";");

        for (var z = 0 ; z < array.length; z++)
        {
            var pos = array[z].indexOf('=');

            if (pos > 0)
            {
                var key = array[z].substring(0, pos);
                var value = array[z].substring(pos + 1);

                if (key=="VCCFG")
                {
                    return (value);
                }
            }
        }
    }
    return "";
}

main();

And the script to do the import:

!INC Local Scripts.EAConstants-JScript

/*
 * Script Name : Import List Of SVN Packages
 * Author      : SDK
 * Purpose     : Imports a package with all of its sub packages generated from 
 *               "Export List Of SVN Packages" script
 * Date        : 01 Aug 2013
 * HOW TO USE  : 1. Get the output file generated by "Export List Of SVN Packages" script
 *                  from your colleague
 *               2. Get the XMIs in the SVN local copy
 *               3. Change the path to the output file in this script if necessary (var filename).
 *                  By default it is "D:\\EAOutput.txt"
 *               4. Change the path to local SVN
 *               5. Run the script
 */

var f; 
var svnPath;

function main()
{
    // CHANGE THE FOLLOWING TWO LINES ACCORDING TO YOUR INPUT AND LOCAL SVN COPY
    var filename = "D:\\EAOutput.txt";
    svnPath = "D:\\svn.xxx.com\\yyy\\docs\\design\\";

    var ForReading = 1, ForWriting = 2, ForAppending = 8;

    Repository.EnsureOutputVisible( "Script" );
    Repository.ClearOutput( "Script" );
    Session.Output("[INFO] Start importing packages from " + filename + ". Please wait...");

    var fso = new ActiveXObject("Scripting.FileSystemObject");
    f = fso.OpenTextFile(filename, ForReading);

    // Read from the file and display the results.
    while (!f.AtEndOfStream)
    {
        var r = f.ReadLine();
        parseLine(r);
        Session.Output("--------------------------------------------------------------------------------");
    }

    f.Close();
    Session.Output("[INFO] Finished");
}

function parseLine(line)
{
    Session.Output("[INFO] Parsing " + line);

    var array = new Array();
    array = (line).split(";");

    var guid;
    var name;
    var isVersionControlled;
    var xmlPath;
    var parentPath;

    isVersionControlled = false;
    xmlPath = "";

    for (var z = 0 ; z < array.length; z++)
    {
        var pos = array[z].indexOf('=');

        if (pos > 0)
        {
            var key = array[z].substring(0, pos);
            var value = array[z].substring(pos + 1);

            if (key=="GUID") {
                guid = value;
            } else if (key=="NAME") {
                name = value;
            } else if (key=="VCCFG") {
                if (value != "") {
                    isVersionControlled = true;
                }
            } else if (key=="XML") {
                if (isVersionControlled) {
                    xmlPath = value;
                }
            } else if (key=="PARENT") {
                parentPath = value;
            }
        }
    }

    // Quick check for target if already exist to speed up process
    var targetPackage as EA.Package;
    targetPackage = Repository.GetPackageByGuid(guid);
    if (targetPackage != null)
    {
        // target exists, do not do anything
        Session.Output("[DEBUG] Target package \"" + name + "\" already exist");
        return;
    }

    var paths = new Array();
    var packages = new Array(paths.Count);

    for (var i = 0; i < paths.Count; i++)
    {
        packages[i] = null;
    }

    paths = (parentPath).split("/");

    if (paths.Count < 2)
    {
        Session.Output("[INFO] Skipped root or level1");
        return;
    }

    packages[0] = selectRoot(paths[0]);
    packages[1] = selectPackage(packages[0], paths[1]);

    if (packages[1] == null)
    {
        Session.Output("[ERROR] Cannot find " + paths[0] + "/" + paths[1] + "in Project Browser");
        return;
    }

    for (var j = 2; j < paths.length; j++)
    {
        packages[j] = selectPackage(packages[j - 1], paths[j]);
        if (packages[j] == null)
        {
            Session.Output("[DEBUG] Creating " + packages[j].Name);

            // create the parent package
            var parent as EA.Package;
            parent = Repository.GetPackageByGuid(packages[j-1].PackageGUID);
            packages[j] = parent.Packages.AddNew(paths[j], "");
            packages[j].Update();
            parent.Update();
            parent.Packages.Refresh();
            break;
        }
    }

    // Check if name (package to import) already exist or not
    var targetPackage = selectPackage(packages[paths.length - 1], name);

    if (targetPackage == null)
    {
        if (xmlPath == "")
        {
            Session.Output("[DEBUG] Creating " + name);

            // The package is not SVN controlled
            var newPackage as EA.Package;
            newPackage = packages[paths.length - 1].Packages.AddNew(name,"");
            Session.Output("New GUID = " + newPackage.PackageGUID);
            newPackage.Update();
            packages[paths.length - 1].Update();
            packages[paths.length - 1].Packages.Refresh();
        }
        else
        {
            // The package is not SVN controlled
            Session.Output("[DEBUG] Need to import: " + svnPath + xmlPath);

            var project as EA.Project;
            project = Repository.GetProjectInterface;
            var result;

            Session.Output("GUID = " + packages[paths.length - 1].PackageGUID);
            Session.Output("GUID XML = " + project.GUIDtoXML(packages[paths.length - 1].PackageGUID));
            Session.Output("XMI file = " + svnPath + xmlPath);
            result = project.ImportPackageXMI(project.GUIDtoXML(packages[paths.length - 1].PackageGUID), svnPath + xmlPath, 1, 0);
            Session.Output(result);

            packages[paths.length - 1].Update();
            packages[paths.length - 1].Packages.Refresh();
        }

    }
    else
    {
        // target exists, do not do anything
        Session.Output("[DEBUG] Target package \"" + name + "\" already exist");
    }
}

function selectPackage(thePackage, childName)
{
    var childPackage as EA.Package;
    childPackage = null;

    if (thePackage == null)
        return null;

    for (var i = 0; i < thePackage.Packages.Count; i++)
    {
        childPackage = thePackage.Packages.GetAt(i);

        if (childPackage.Name == childName)
        {
            Session.Output("[DEBUG] Found " + childName);
            return childPackage;
        }
    }

    Session.Output("[DEBUG] Cannot find " + childName);
    return null;
}

function selectRoot(rootName)
{
    for (var y = 0; y < Repository.Models.Count; y++)
    {
        root = Repository.Models.GetAt(y);
        if (root.Name == rootName)
        {
            return root;
        }
    }
    return null;
}

main();