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#}}==

Start the program with "server" parameter to start the server, and "client" to start the client. The client will send data to the server and receive a response. The server will wait for data, display the data received, and send a response.

 

using System;

using System.IO;

public string Loot = "140 tonnes of jade";

}

 

=={{header|D}}==

 

This library is not standard, so this code (by Adam D. Ruppe) could and should be rewritten using more standard means.

 

struct S1 {

server.eventLoop;

}

 

=={{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]).

 

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

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

 

running it (*comes later)

 

===Server===

QUALIFIED: concurrency.messaging

: prettyprint-message ( -- ) concurrency.messaging:receive . flush prettyprint-message ;

[ prettyprint-message ] "logger" spawn dup name>> register-remote-thread

 

Note: we are using QUALIFIED: with the concurrency.messaging vocabulary because the "receive" word is defined in io.sockets vocabulary too. If someone have a cleaner way to handle this.

 

===Client===

QUALIFIED: concurrency.messaging

{ "Hello Remote Factor!" H{ { "key1" "value1" } } }

 

How to Run:

 

'''Server:'''

 

import (

}

http.Serve(listener, nil)

'''Client:'''

 

import (

}

fmt.Printf("Tax on %.2f: %.2f\n", amount, tax)

{{out | Client output}}

<pre>

 

'''.proto:'''

 

service TaxComputer {

message Amount {

int32 cents = 1;

'''Server:'''

 

import (

taxcomputer.RegisterTaxComputerServer(grpcServer, &taxServer{.05})

grpcServer.Serve(listener)

'''Client:'''

 

import (

}

fmt.Println("Tax on", amt.Cents, "cents is", tax.Cents, "cents")

{{out | Client output}}

<pre>

 

Like gRPC, Thrift requires a language independent interface definition file:

i32 tax(1: i32 amt)

'''Server:'''

 

import (

log.Fatal(err)

}

'''Client:'''

 

import (

}

transport.Close()

{{out | Client output}}

<pre>

===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|Julia}}==

If a group of CPUs, including multiple cores on a single machine or a cluster running with paswordless ssh login, is used,

the following can be set up as an example:

 

function count_heads(n)

end

c

We then run the following on the primary client:

using Distributed

@everywhere include_string(Main, $(read("count_heads.jl", String)), "count_heads.jl")

b = @spawn count_heads(100000000) # runs on another available processor

 

100001564

</pre>

In one terminal window, start up the REPL

 

$ ./bin/lfe

Erlang/OTP 17 [erts-6.2] [source] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:false]

LFE Shell V6.2 (abort with ^G)

>

 

And then enter the following code

 

> (defun get-server-name ()

(list_to_atom (++ "exampleserver@" (element 2 (inet:gethostname)))))

(x

(io:format "Unexpected pattern: ~p~n" `(,x)))))

 

===Client===

In another terminal window, start up another LFE REPL and ender the following code:

 

> (defun get-server-name ()

(list_to_atom (++ "exampleserver@" (element 2 (inet:gethostname)))))

(io:format "Unexpected pattern: ~p~n" (list x))))

'ok)

 

To use this code, simply start the server in the server terminal:

 

> (start)

exampleserver@yourhostname ready

ok

(exampleserver@yourhostname)>

 

Send some messages from the client terminal:

 

> (send "hi there")

connecting to exampleserver@yourhostname

ok

(exampleclient@yourhostname)>

 

And check out the results back in the server terminal window:

 

Got "hi there" from exampleclient@yourhostname

Got 42 from exampleclient@yourhostname

Got {key,value} from exampleclient@yourhostname

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

The following sends a request for a random number to be generated on each of two nodes, these are then transmitted back to be assembled into an array with two elements. Omitting the first line, will cause the program to be run on all configured remote computers.

ParallelEvaluate[RandomReal[]]

 

=={{header|Nim}}==

{{libheader|nanomsg}}

 

echo "SENDING \"",msg,"\""

let bytes = s.send(msg.cstring, msg.len + 1, 0)

assert bytes == msg.len + 1

 

var buf: cstring

let bytes = s.recv(addr buf, MSG, 0)

discard freemsg buf

 

var to: cint = 100

discard s.setSockOpt(SOL_SOCKET, RCVTIMEO, addr to, sizeof to)

node0 paramStr(2)

elif paramStr(1) == "node1":

Usage:

<pre>./pair node0 tcp://127.0.0.1:25000

 

<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"

 

}

return 0;

 

===Client===

<tt>client.m</tt>

#import "ActionObjectProtocol.h"

 

}

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

 

 

===Socket, Pickle format===

 

==== Server ====

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

print 'Exiting...'

rpcserver.server_close()

 

==== Client ====

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

print '42/2 is:', rpcclient.div(divisor=2, dividend=42)

rpcclient._close()

 

===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|Racket}}==

Server and client in the same piece of code, running a useless (fib 42) computation, four times, on four hosts (which all happen to be "localhost", but that can change, of course).

 

#lang racket/base

(require racket/place/distributed racket/place)

(printf "Results: ~s\n" (map *channel-get places))

(exit))))

 

=={{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}}==

{{alertbox|yellow|'''Security risk!''' Anything, able to reach 127.0.0.1 port 1234, can run shell commands as the user who runs the server. This allows other users to gain privileges.}}

 

 

Limitations:

 

===Client===

 

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

 

{{omit from|Lotus 123 Macro Scripting}}