1 / 20

Comet: Enabling Erlang Programs to Interact with COM Components

Comet is a port and gen_server module designed for Erlang programs to deploy and interact with Microsoft COM components. Currently under development, Comet is featured in OTP release 7B, facilitating the integration of Erlang applications with the Common Object Model (COM) on Windows. It supports both Distributed COM (DCOM) and COM+, allowing for a range of functionalities from creating and manipulating COM objects to handling asynchronous calls. Comet efficiently maps Erlang types to COM types, enhancing interoperability between systems.

ghalib
Télécharger la présentation

Comet: Enabling Erlang Programs to Interact with COM Components

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Comet - an Erlang-to-COM Port • Comet is a port and a gen_server module that enables Erlang programs to deploy COM components • Comet is under development, an early version is part of OTP release 7B

  2. COM • Common Object Model • A standard for component development from Microsoft • Windows-only (although a third-party version exist on Solaris) • Rival to CORBA on the Windows platform • All Microsoft programs use COM • Support for distribution, DCOM and COM+

  3. COM Model • Classes presents interfaces • Interfaces are a bunch of related functions or methods • No data are exposed, only interfaces • Properties of objects accessible through access-functions

  4. COM Model continued • IDL describes classes and interfaces • IDL compiles into a type-library that can be browsed with a tool • Two ways to use a class • Dispatch - a special interface for interpreted languages • Virtual Interface - faster, for compiled languages • Comet can use both (although dispatch is safer)

  5. COM Memory Handling • Reference-counting • Language support in Visual Basic, “Java” (and C#) • Erlang programs must (currently) explicitly free interfaces

  6. Erlang Ports • A way to call external code from Erlang • Implemented as a linked in driver (DLL) or a port program • Comet offers both • port driver is considerably faster • port program is safer, if the COM server crashes, it won’t bring the emulator down • A gen_server module interfaces to the port program or driver • The Comet port driver and program are multithreaded

  7. Comet as a Port Driver • An application calling a COM Object • Comet as a driver Erlang process some_application ErlComDrv.dll erl_com thread IWhatever

  8. Comet as a Port Program • An application calling a COM Object • Comet as a port program Erlang process some_application ErlComDrv.exe erl_com thread IWhatever

  9. Calling COM from Erlang • All calls through the gen_server module “erl_com” • erl_com provides methods for calling • erl_com has functions for: • creating objects • fetching interfaces • releasing interfaces and objects • retrieving type information of objects and types • creating threads for calling COM objects asynchronously

  10. A Simple Example • An interface that implements some utilities • Calling it from Erlang interface ISomeUtilities : IDispatch { [id(1)] HRESULT DaysBetween([in] DATE date1, [in] DATE date2, [out, retval] double* daysBetween); [id(2)] HRESULT ReplaceAll([in] BSTR inStr, [in] BSTR keyStr, [in] BSTR newStr, [out, retval] BSTR* outStr); ... }; ... S= “It was a dark and stormy night...”, I= erl_com:create_dispatch(T, “{class id for SomeUtilities}”), S2= erl_com:invoke(I, “ReplaceAll”, [S, “stormy”, “still”]), D= erl_com:invoke(I, “DaysBetween”, [{vt_date, {{2000, 1, 1}, {0, 0, 0}}}, {vt_date, erlang:now()}]) erl_com:release(I), ...

  11. Mapping COM Types to Erlang • COM uses a small set of types • Comet mapps Erlang types to COM types through the use of tuples • Basic types are converted properly: integers, floats, strings and booleans • Other types are prefixed in a tuple, e.g. {vt_date {1999, 12, 12}, {}} • Constants in COM are enumerations • Strings currently 8-bits in Comet • Complex types as structures, are currently not supported

  12. Invoke (dispatch interface) • The invoke method in the dispatch interface is used to late-bind to interfaces • Comet provides the methods invoke, property_put and property_get • Errors returned as {com_error, Code} • Can have named parameters (not support in Comet yet) ... Obj= erl_com:create_object(T, “{class id}”), I= erl_com:query_interface(Obj, “{a dispatch interface id}”), Value= erl_com:invoke(I, “Method”, [parameters]), erl_com:property_put(I, “Property”, [parameters], Value2), Value3= erl_com:property_get(I, “AnotherProperty”), ...

  13. Calling a Virtual Interface • A virtual interface is an array of function pointers • Virtual Method Table used for C++ objects • Called in Comet using assembler glue • Every parameter, including return value, must be explicitly typed • Address of virtual function must be specified • Only practical when code is generated • Wrong parameters cause Comet to crash ... [Outstr]= erl_com:com_call(I_, 36, [{vt_str, InStr}, {vt_str, out}]), ...

  14. {ok, Pid}= erl_com:start_process(), T= erl_com:new_thread(Pid), Obj= erl_com:create_dispatch(T, "InternetExplorer.Application", ?CLSCTX_LOCAL_SERVER), erl_com:invoke(Obj, "Navigate", ["www.erlang.org"]), erl_com:property_put(Obj, "Visible", true), Obj. 1 2 3 Browser Example • The Internet Explorer browser presents COM interfaces • Example: creating an Internet Explorer and navigating to a URL 1 opens a Comet process and a thread in it 2 creates an object, retrieves its default interface 3 invokes the methods “navigate” and the “visible”

  15. Excel Example • Excel is also accessible through COM • Easiest way is to start with a Visual Basic-program • The Excel macro recorder can generate these • Example: adding a graph Visual Basic: Charts.Add ActiveChart.ChartType = xlPieExploded Erlang: Charts = erl_com:package_interface(E, erl_com:property_get(E, "Charts")), erl_com:invoke(Charts, "Add"), C= erl_com:package_interface(E, erl_com:property_get(E, "ActiveChart")), erl_com:property_put(C, "ChartType", ?XlPieExploded),

  16. Generating Glue Code • Can be used for both virtual- and dispatch-interfaces • Type libraries, compiled from COM IDL, describes COM classes and interfaces • Comet reads information from Type Libraries • Erlang modules are generated with glue code • Each interface generates a module • Each enum (set of constants) generates a module and a header-file with macros

  17. Excel Example with Generated Code • (Code is generated from the Excel type-library) Visual Basic: Charts.Add ActiveChart.ChartType = xlPieExploded ActiveChart.SetSourceData _ Source:=Sheets("Sheet1").Range("B2:C4"), _ PlotBy:=xlColumns ActiveChart.Location Where:=xlLocationAsObject, Name:="Sheet1" Erlang: charts:add(xc_Application:charts(E)), ActiveChart= xc_Application:activeChart(E), chart:chartType(ActiveChart, ?XlPieExploded), R= sheets:range(xc_Application.sheets(E, “Sheet1”), “B2:C4”), chart:setSourceData(ActiveChart, R, ?xlColumns), chart:location(ActiveChart, ?xlLocationAsObject, "Sheet1"),

  18. Problems • Combining an object-oriented approach with Erlang’s semi-functional • Handling state • Memory management • Type conversions between Erlang and other system • Asynchronous operations • Performance considerations • Robustness

  19. Future Improvements • Feedback needed • Improvements considered • Full Unicode support • Calling Erlang from COM • Event Sinks • Erlang COM Servers • COM+ Distribution • Complex types • Other API’s on other platforms • Combining COM’s ref-counting with Erlang’s GC

  20. References • Comet documentation from OTP • Don Box: Essential COM (Addison Wesley) • Box, Brown, Ewald and Sells: Effective COM (Addison Wesley) • Oberg: Understanding & Programming COM+ (Prentice Hall) • Jason Pritchard: COM and Corba Side by Side (Addison Wesley)

More Related