Distributed programming: Difference between revisions

 

server.ads:

pragma Remote_Call_Interface;

procedure Foo;

function Bar return Natural;

 

server.adb:

Count : Natural := 0;

 

return Count;

end Bar;

 

client.adb:

with Ada.Text_IO;

 

Server.Foo;

Ada.Text_IO.Put_Line ("Calling Bar: " & Integer'Image (Server.Bar));

 

required config (dsa.cfg):

pragma Starter (None);

 

procedure Client;

for Client_Partition'Main use Client;

 

compilation:

 

=={{header|C}}==

This program is in a sense both a server and a client, depending on if its task is spawned with a command-line argument: if yes, it spawns another task of the same executible on the parallel virtual machine and waits for it to transmit data; if no, it transmits data and is done.

#include <stdlib.h>

#include <pvm3.h>

pvm_exit();

return 0;

spawn -> /tmp/a.out 1

[2]

[2:t40028] got msg type 1: 1804289383 0.394383

[2:t40028] EOF

 

=={{header|C sharp|C#}}==

 

using System.Net.Sockets;

 

{

 

 

 

 

 

 

 

 

 

 

 

 

{

 

 

 

 

 

 

 

 

 

 

}

 

 

 

 

=={{header|E}}==

(The protocol is symmetric; this program is the server only in that it is the one which is started first and exports an object.)

 

 

def logService {

def sturdyRef := makeSturdyRef.temp(logService)

println(<captp>.sturdyToURI(sturdyRef))

 

This will print the URL of the service and run it until aborted.

The URL provided by the server is given as the argument to this program.

 

introducer.onTheAir()

def sturdyRef := <captp>.sturdyFromURI(uri)

println(`At $time: $line`)

}

 

=={{header|Erlang}}==

srv.erl

 

-export([start/0, wait/0]).

 

wait();

Any -> io:fwrite("Error ~p~n", [Any])

 

=== Client ===

client.erl

 

-export([start/0, wait/0]).

 

erlang:set_cookie(node(), rosetta),

{ok,[[Srv]]} = init:get_argument(server),

{srv, list_to_atom(Srv)} ! {echo,self(), hi},

wait(),

{hello, Any} -> io:fwrite("Received ~p~n", [Any]);

Any -> io:fwrite("Error ~p~n", [Any])

 

running it (*comes later)

|erlc client.erl

|erl -run client start -run init stop -noshell -server srv@agneyam

Received hi

=={{header|Go}}==

 

import (

"net"

)

 

 

if err != nil {

}

if err != nil {

fmt.Println(err)

}

 

if err != nil {

}

 

 

 

}

 

 

import (

"fmt"

)

 

func main() {

}

 

if err != nil {

}

 

 

 

if err != nil {

}

if err != nil {

}

<pre>

</pre>

 

=={{header|JavaScript}}==

===Server===

 

 

var server = net.createServer(function (c){

 

server.listen(3000, 'localhost')

 

===Client===

 

conn = net.createConnection(3000, '192.168.1.x')

conn.on('data', function(msg){

console.log(msg.toString())

 

=={{header|Objective-C}}==

 

<tt>ActionObjectProtocol.h</tt>

// our protocol allows "sending" "strings", but we can implement

// everything we could for a "local" object

@protocol ActionObjectProtocol

- (NSString *)sendMessage: (NSString *)msg;

 

<tt>ActionObject.h</tt>

#import "ActionObjectProtocol.h"

 

@interface ActionObject : NSObject <ActionObjectProtocol>

// we do not have much for this example!

 

<tt>ActionObject.m</tt>

#import "ActionObject.h"

 

return @"server answers ...";

}

 

<tt>server.m</tt>

#import "ActionObject.h"

 

int main (void)

{

 

 

 

 

 

return 0;

 

===Client===

<tt>client.m</tt>

#import "ActionObjectProtocol.h"

 

int main(void)

{

 

 

 

 

 

return 0;

 

=={{header|OCaml}}==

 

=== Server ===

let create_logger () =

register "search" search;

Join.Site.listen (Unix.ADDR_INET (Join.Site.get_local_addr(), 12345));

 

=== Client ===

 

let ns_there = Join.Ns.there (Unix.ADDR_INET (Join.Site.get_local_addr(), 12345))

log "foo";

log "shoe";

 

=={{header|Oz}}==

We show a program that starts a server on a remote machine, exchanges two messages with that server and finally shuts it down.

 

functor ServerCode

export

 

%% shut down server

 

=={{header|Perl}}==

Using Data::Dumper and Safe to transmit arbitrary data structures as serialized text between hosts. Same code works as both sender and receiver.

use IO::Socket::INET;

use Safe;

 

sub get_data {

LocalHost => "localhost",

LocalPort => "10000",

Proto => "tcp",

Listen => 1,

unless ($sock) { die "Socket creation failure" }

my $cli = $sock->accept();

# of course someone may be tempted to send you 'system("rm -rf /")',

# to be safe(r), use Safe::

my $x = $safe->reval(join("", <$cli>));

close $cli;

my $host = shift;

my $data = shift;

PeerAddr => "$host:10000",

Proto => "tcp",

 

unless ($sock) { die "Socket creation failure" }

} else {

send_data('some_host', { a=>100, b=>[1 .. 10] });

=={{header|PicoLisp}}==

===Server===

(let? Sock (accept @)

(unless (fork) # Handle request in child process

(pr (eval @)) ) ) ) # Evaluate and send reply

(bye) ) # Exit child process

===Client===

(out Sock (pr '*Pid)) # Query PID from server

(println 'PID (in Sock (rd))) # Receive and print reply

(out Sock (pr '(* 3 4))) # Request some calculation

(println 'Result (in Sock (rd))) # Print result

Output:

<pre>PID 18372

 

==== Server ====

# -*- coding: utf-8 -*-

 

except KeyboardInterrupt:

print 'Exiting...'

 

==== Client ====

# -*- coding: utf-8 -*-

 

# control if foo_function returns True

if rpc.foo_function():

 

===HTTP===

 

==== Server ====

# -*- coding: utf-8 -*-

 

except KeyboardInterrupt:

print 'Exiting...'

 

==== Client ====

# -*- coding: utf-8 -*-

 

print 'Server Status: %d' % response.status

 

 

 

 

==== Server ====

# -*- coding: utf-8 -*-

import SocketServer

HOST = "localhost"

PORT = 8000

 

def handle(self):

 

if __name__ == '__main__':

try:

except KeyboardInterrupt:

print 'Exiting...'

 

==== Client ====

# -*- coding: utf-8 -*-

import socket

HOST = "localhost"

PORT = 8000

 

 

 

 

 

===Pyro===

 

==== Server ====

# -*- coding: utf-8 -*-

 

except KeyboardInterrupt:

print 'Exiting...'

 

==== Client ====

# -*- coding: utf-8 -*-

 

 

print 'We sent two numbers to divide: %d and %d' % (NUM1, NUM2)

 

=== Spread ===

 

==== Client (Listener) ====

# -*- coding: utf-8 -*-

 

if hasattr(recv, 'sender') and hasattr(recv, 'message'):

print 'Sender: %s' % recv.sender

 

==== Client (Sender) ====

# -*- coding: utf-8 -*-

 

 

conn.multicast(spread.RELIABLE_MESS, 'test', 'hello, this is message sent from python')

 

=={{header|Ruby}}==

 

'''Server'''

 

# The URI for the server to connect to

DRb.start_service(URI, FRONT_OBJECT)

# Wait for the drb server thread to finish before exiting.

 

'''Client'''

 

# The URI to connect to

 

timeserver = DRbObject.new_with_uri(SERVER_URI)

 

=={{header|Tcl}}==

A rudimentary IRC Server

global connections

set connections [dict create]

}

 

Client

global argv argc

if {$argc != 2} {

}

 

 

=={{header|UnixPipes}}==

 

===Server===

 

===Client===

 

Now you can enter commands in the client terminal and get the output back through the same connection.

 

{{omit from|PARI/GP}}

{{omit from|Retro}}