Free procedure call software for linux

RPC::XML::Procedure is an object encapsulation of server-side RPC procedures.

SYNOPSIS

require RPC::XML::Procedure;

...
$method_1 = RPC::XML::Procedure->new({ name => system.identity,
code => sub { ... },
signature => [ string ] });
$method_2 = RPC::XML::Procedure->new(/path/to/status.xpl);

IMPORTANT NOTE

This package is comprised of the code that was formerly RPC::XML::Method. The package was renamed when the decision was made to support procedures and methods as functionally different entities. It is not necessary to include both this module and RPC::XML::Method -- this module provides the latter as an empty subclass. In time, RPC::XML::Method will be removed from the distribution entirely.

The RPC::XML::Procedure package is designed primarily for behind-the-scenes use by the RPC::XML::Server class and any subclasses of it. It is documented here in case a project chooses to sub-class it for their purposes (which would require setting the method_class attribute when creating server objects, see RPC::XML::Server).

This package grew out of the increasing need to abstract the operations that related to the methods a given server instance was providing. Previously, methods were passed around simply as hash references. It was a small step then to move them into a package and allow for operations directly on the objects themselves. In the spirit of the original hashes, all the key data is kept in clear, intuitive hash keys (rather than obfuscated as the other classes do). Thus it is important to be clear on the interface here before sub-classing this package.

PyOPC is a Python library implementing the OPC XML Data Access Protocol Version 1.01 (OPC XML-DA 1.01).

PyOPC supports the easy creation of XMLDA-compliant clients and servers without having to deal with the SOAP protocol and server issues.

The Open Linking and Embedding for Process Control (OPC) consortium released several open standards, which address interfaces for vertical integration in industrial automation.

Historically, OPC used the Distributed Component Object Model (DCOM) for the underlying communication technology. DCOM has the disadvantage of being platform specific: it is only available for Microsoft Windows based systems. Other platforms, such as Linux, can therefore not retrieve fieldbus data from DCOM based servers.

Another disadvantage of DCOM is that it can not easily bypass firewalls, hence access will often be limited to certain segments of a corporate network.
In the last years, a new technology, called SOAP Web services, emerged. [LIV02] defines a Web Service as: ``a method or function that is available for other applications to access over the Internet.. Web services enable Remote Procedure Calls (RPC) and have the following key features:

High level of interoperability:

Web services technologies are all based on strictly defined open standards1.

High networking abilities:

As an underlying communication protocol, Web services utilize Internet protocols such as the Hyper Text Transfer Protocol (HTTP) or the Simple Mail Transfer Protocol (SMTP). These protocols have high networking abilities and may moreover penetrate firewalls.

Protocol legible by humans:

The Simple Object Access Protocol (SOAP)2 is based on the Extended Markup Language (XML), which is legible to humans. This way, testing and debugging of Web services is far easier than with binary protocols.

Documentation:

Another underlying technology of SOAP is the ``Web Service Definition Language (WSDL) which may be used to define the service, especially by constraining the format of the SOAP protocol. WSDL utilizes the XML Schema language for defining these SOAP messages3. These WSDL documents can be utilized by frameworks to generate stubs that provide a base for accessing a Web service.

Validation:

WSDL in combination with a validating XML parser enable the validation of SOAP messages. This way, custom code will never receive syntactically or semantically erroneous data, which should improve the stability of the service.

SOAP Web services are seen as a successor to several alternative technologies such as DCOM and are already broadly accepted by the industry. More information about the SOAP protocol can be found in [SEE02] and [LIV02].

The OPC consortium reacted on this technological evolution by adopting SOAP Web services for their standards. One recent addition of OPC is the "XML Data Access Version 1.0" (XML-DA 1.0) standard. This standard deals with access of underlying fieldbus technologies and covers the following aspects:

Information model:

The specification provides a simple information model, based on ``OPC Items which represent a piece of information, similar to fieldbus data points. These items can be arranged hierarchically.

Data types:

OPC XML-DA adopts several XML-Schema based data types, such as integer, float, date/time specific types. Moreover it defines arrays which are based on these basic types.

Operations:

The standard specifies 8 operations such as reading/writing and browsing which can be used to access the underlying fieldbus.

Subscription:

The specification further introduces a mechanism to retrieve only changed items, called ``Subscription. Clients may thus subscribe to items and use a dedicated polling operation to retrieve changed data.

TurboCall is an extension which adds a phone call function to your browser.
Select any phone number on any web page, or click on a phone number in your contact list in the integrated panel, and you will receive an incoming call from the desired destination number within seconds.
Main features:
- No obligation to subscribe after trial period
- Use your regular landline or cell phone
- Low international rates!
- Accessible worldwide
- Store your personal contact list
- No connection fee, no maintenance fee!

RPyC stands for Remote Python Call, a pun over remote procedure call. It is completely transparent and symmetrical. It is inspired by the work of eyal lotem (pybuild.sf.net) on pyinvoke, and was made for two purposes:
Learning the lowlevel of the python language attempting to improve pyinvoke by making the entire protocol symmetrical. This means the client can make requests to the server, and the server can reply with requests of its own (the client is also a server on its own). This typically means using callback functions.
The RPyC package comes with a full demo, showing (or showing-off) many of its features. As i said, its completely transparent and symmetrical, so you can write code just as you would write in the case of normal python programs.
demo 1 -- a simple client demo
# import the client
from Rpyc.Client import RpycSocketClient
# `hostname` is the name of the host running an Rpyc server
# the port parameter is optional
c = RpycSocketClient("hostname")
# now we are connected and can start messing around with stuff on the server
for filename in c.modules.os.listdir("/tmp"):
print "found file", filename
Enhancements:
- This release adds DeliveringNamespace, LoginError (instead of tlslites internal errors), __version__, deliver (the counterpart of obtain, which can now deliver and obtain functions as well), and isproxy (to test whether an object is a proxy).
- It improves memory consumption with __slots__ and the isinstance/issubclass mechanism.

Python Call Graph (pycallgraph) is a Python library that creates call graphs for Python programs

pycallgraph is quite new. It seems to work well and I will most likely improve it in the near future!

Nemesis Pascal is an Pascal interpreter that is:

Free
Open Source (GPL)
Cross-platform (currently Windows and Linux)

Nemesis Pascal is written in Delphi and Kylix. Borland CLX libraries supplies the cross-platform features.

The Nemesis Pascal applications runs on Windows using native controls, and Linux using the CLX Library (a binding to Qt Trolltech).

Exemple:

unit test1;

interface

implementation

procedure main;
begin
ShowMessage(Hello World!);
end;

end.

Devel::CallerItem is an Perl object representing a function call from the stack of function calls.

SYNOPSIS

Usage:

require Devel::CallerItem;

$call = Devel::CallerItem->from_depth($depth) || return;
$passed_arguments_ref = $call->argument_list_ref();
$callpack = $call->pack();
$callfile = $call->file();
$callline = $call->line();
$callsub = $call->subroutine();
$bool = $call->has_args();
$bool = $call->wants_array();
($arg_ref,@caller) = $call->as_array();
$call_string = $call->as_string($print_level);
$passed_arguments_string = $call->arguments_as_string();

$printable_arg = Devel::CallerItem->printable_arg($arg,$print_level);

Devel::CallerItem objects hold all the information about a specific function call on the stack. The information is basically that obtained from caller and @DB::args, packaged into an object. This comes with some useful methods to print the object in a nice way.

portmap is a part of the ONCRPC collection of software for implementing remote procedure calls between computer programs. This project is use widely by NFS and NIS, and assorted other systems.
Some make variable can be used to control compilation.
NO_TCP_WRAPPER= if non-empty, doent use tcp_wrappers
USE_DNS= if set, tcp_wrappers can check peers based on hostname
as well as IP address. This should only be used if you
are certain that gethostbyname will never trigger a
called to portmap (as it might if nis is used for hostnames).
RPCUSER= is set, portmap will use getpwnam to find the user for
that user, and will setuid to that user before listening
for incoming messages
DAEMON_UID= Can be set to a number to override the default UID
to setuid to. Default is 1.
DAEMON_GID= As above, but for setgid.
Enhancements:
- This first new release in 10 years combines assorted patches from different Linux distributions.
- Security was improved so that privileged services can register non-privileged ports that cannot then be unregistered by other users.