Palvelin, c, c++ tai python, .... sittenkin c? (eli osa 2)

[teele]

Olen kokeillut muutamia palvelimia, joiden koodit on netistä löytyneet, mutta c ja c++ -palvelimet näyttävät olevan vähän vanhempaa mallia. Osaisiko joku suositella "helppoa" ja nyky-c++ mukaista palvelinta, joka osaisi palvella useaa asiakasta samanaiakisesti.

Löytämäni python palvelin ei ainakaan vielä toimi kahden asiakkaan kanssa.

Koodia: [Valitse]


### lähde: http://www.techbeamers.com/python-tutorial-write-multithreaded-python-server/


import socket
from threading import Thread
from socketserver import ThreadingMixIn

# Multithreaded Python server : TCP Server Socket Thread Pool
class ClientThread(Thread):
 
    def __init__(self,ip,port):
        Thread.__init__(self)
        self.ip = ip
        self.port = port
        print( "[+] New server socket thread started for " + ip + ":" + str(port) )
 
    def run(self):
        while True :
            data = conn.recv(2048)
            print( "Server received data:", data )
            MESSAGE = input("Multithreaded Python server : Enter Response from Server/Enter exit:")
            if MESSAGE == 'exit':
                break
            conn.send(MESSAGE.encode('utf-8'))  # echo

# Multithreaded Python server : TCP Server Socket Program Stub
TCP_IP = '0.0.0.0'
TCP_PORT = 2004
BUFFER_SIZE = 20  # Usually 1024, but we need quick response

tcpServer = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcpServer.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
tcpServer.bind((TCP_IP, TCP_PORT))
threads = []
 
while True:
    tcpServer.listen(4)
    print( "Multithreaded Python server : Waiting for connections from TCP clients..." )
    (conn, (ip,port)) = tcpServer.accept()
    newthread = ClientThread(ip,port)
    newthread.start()
    threads.append(newthread)
 
for t in threads:
    t.join()


Näillä asiakkailla olen kokeillut

Koodia: [Valitse]


### lähde: http://www.techbeamers.com/python-tutorial-write-multithreaded-python-server/

# Python TCP Client A
import socket

host = socket.gethostname()
port = 2004
BUFFER_SIZE = 2000
MESSAGE = input("tcpClientA: Enter message/ Enter exit:")
###mesg = MESSAGE.encode('utf-8')
 
tcpClientA = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcpClientA.connect((host, port))

while MESSAGE != 'exit':
    tcpClientA.send(MESSAGE.encode('utf-8'))     
    data = tcpClientA.recv(BUFFER_SIZE)
    print( " Client2 received data:", data.decode('utf-8') )
    MESSAGE = input("tcpClientA: Enter message to continue/ Enter exit:")
    ###mesg = MESSAGE.encode('utf-8')

tcpClientA.close()

ja

Koodia: [Valitse]


### lähde: http://www.techbeamers.com/python-tutorial-write-multithreaded-python-server/

# Python TCP Client B
import socket

host = socket.gethostname()
port = 2004
BUFFER_SIZE = 2000
MESSAGE = input("tcpClientB: Enter message/ Enter exit:")
mesg = MESSAGE.encode('utf-8')
 
tcpClientB = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcpClientB.connect((host, port))

while MESSAGE != 'exit':
    tcpClientB.send(mesg)     
    data = tcpClientB.recv(BUFFER_SIZE)
    print( " Client received data:", data )
    MESSAGE = input("tcpClientB: Enter message to continue/ Enter exit:")
    mesg = MESSAGE.encode('utf-8')

tcpClientB.close()


Muistaakseni olen kokeillut c-puolelta select, thread ja fork-mallisia palvelimia, mutta en oikeastaan tiedä, mikä olisi kätevin tilanteessa, jossa palvelimelle menee asiakkilta tietoa suunnilleen yksi rivillinen ja palvelin lähettää tietoa asiakkailleen suunnillen aina yhden rivillisen verran. Asiakkaat toimittavat tietoa palvelimelle ehkä kerran minuutissa, mutta olisi hyvä, jos palvelin pystyisi vastaamaan asiakkaalle vaikka 10 sekunnin sisällä.

[nm]

Suosittelen HTTP:tä ja REST-tyyppistä rajapintaa tuollaiseen palveluun. Lyhyt esittely, jos termi ei ole ennestään tuttu: http://www.tivi.fi/Kaikki_uutiset/rest-on-nettipalveluiden-yhteinen-kieli-6652501
Aihepiiriin pääsee nopeasti sisälle tutkimalla olemassa olevien palvelujen dokumentaatiota. Esimerkiksi:

https://github.com/finnishtransportagency/digitraffic/wiki/Data%E2%80%93rajapinnat
https://www.theseus.fi/bitstream/handle/10024/116833/Nettiauto%20REST-rajapinnan%20dokumentointi.pdf?sequence=1


Pythonin tapauksessa pienten ja keskisuurten web-palvelujen rakenteluun sopivia microframeworkeja ovat mm. Flask ja Pyramid.

C:llä/C++:lla en itse lähtisi toteuttamaan tällaista verkkorajapintaa ainakaan mihinkään kevyeen harrasteprojektiin. Jos on tarvetta suorittaa joku erittäin raskas C:llä koodattu laskentaoperaatio, kannattaa ensin miettiä, voisiko sen toteuttaa esim. Numpy:n tai vastaavan laskentakirjaston avulla. Jos ei, seuraava vaihtoehto olisi tehdä sille C-funktiolle Python-rajapinta, jota voi sitten kutsua Pythonilla toteutetusta palvelinohjelmasta.

[teele]

Kiitos,
oli hyviä ohjeita. Yritän nyt omaksusa niistä sen verran, että pääsen alkuun.

Löysin netistä c -muotoisen multiserverin, joka hyväksyy useita asiakkaita, ja se voisi olla sopiva.

Koodia: [Valitse]

[
// lähde: http://www.geeksforgeeks.org/socket-programming-in-cc-handling-multiple-clients-on-server-without-multi-threading/
// yksittäispalvelin oli täällä: http://www.geeksforgeeks.org/socket-programming-cc/


//Example code: A simple server side code, which echos back the received message.
//Handle multiple socket connections with select and fd_set on Linux

#include <stdio.h>
#include <string.h>   //strlen
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>   //close
#include <arpa/inet.h>    //close
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/time.h> //FD_SET, FD_ISSET, FD_ZERO macros
   
#define TRUE   1
#define FALSE  0
#define PORT 8888
   
int main(int argc , char *argv[]) 
{ 
    int opt = TRUE; 
    int master_socket , addrlen , new_socket , client_socket[30] ,
          max_clients = 30 , activity, i , valread , sd; 
    int max_sd; 
    struct sockaddr_in address; 
       
    char buffer[1025];  //data buffer of 1K
       
    //set of socket descriptors
    fd_set readfds; 
       
    //a message
    char *message = "ECHO Daemon v1.0 \r\n"; 
   
    //initialise all client_socket[] to 0 so not checked
    for (i = 0; i < max_clients; i++) 
    { 
        client_socket[i] = 0; 
    } 
       
    //create a master socket
    if( (master_socket = socket(AF_INET , SOCK_STREAM , 0)) == 0) 
    { 
        perror("socket failed"); 
        exit(EXIT_FAILURE); 
    } 
   
    //set master socket to allow multiple connections ,
    //this is just a good habit, it will work without this
    if( setsockopt(master_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&opt,
          sizeof(opt)) < 0 ) 
    { 
        perror("setsockopt"); 
        exit(EXIT_FAILURE); 
    } 
   
    //type of socket created
    address.sin_family = AF_INET; 
    address.sin_addr.s_addr = INADDR_ANY; 
    address.sin_port = htons( PORT ); 
       
    //bind the socket to localhost port 8888
    if (bind(master_socket, (struct sockaddr *)&address, sizeof(address))<0) 
    { 
        perror("bind failed"); 
        exit(EXIT_FAILURE); 
    } 
    printf("Listener on port %d \n", PORT); 
       
    //try to specify maximum of 3 pending connections for the master socket
    if (listen(master_socket, 3) < 0) 
    { 
        perror("listen"); 
        exit(EXIT_FAILURE); 
    } 
       
    //accept the incoming connection
    addrlen = sizeof(address); 
    puts("Waiting for connections ..."); 
       
    while(TRUE) 
    { 
        //clear the socket set
        FD_ZERO(&readfds); 
   
        //add master socket to set
        FD_SET(master_socket, &readfds); 
        max_sd = master_socket; 
           
        //add child sockets to set
        for ( i = 0 ; i < max_clients ; i++) 
        { 
            //socket descriptor
            sd = client_socket[i]; 
               
            //if valid socket descriptor then add to read list
            if(sd > 0) 
                FD_SET( sd , &readfds); 
               
            //highest file descriptor number, need it for the select function
            if(sd > max_sd) 
                max_sd = sd; 
        } 
   
        //wait for an activity on one of the sockets , timeout is NULL ,
        //so wait indefinitely
        activity = select( max_sd + 1 , &readfds , NULL , NULL , NULL); 
     
        if ((activity < 0) && (errno!=EINTR)) 
        { 
            printf("select error"); 
        } 
           
        //If something happened on the master socket ,
        //then its an incoming connection
        if (FD_ISSET(master_socket, &readfds)) 
        { 
            if ((new_socket = accept(master_socket,
                    (struct sockaddr *)&address, (socklen_t*)&addrlen))<0) 
            { 
                perror("accept"); 
                exit(EXIT_FAILURE); 
            } 
           
            //inform user of socket number - used in send and receive commands
            printf("New connection , socket fd is %d , ip is : %s , port : %d \n" ,
                    new_socket , inet_ntoa(address.sin_addr) , ntohs(address.sin_port)); 

         
            //send new connection greeting message
            if( send(new_socket, message, strlen(message), 0) != strlen(message) ) 
            { 
                perror("send"); 
            } 
               
            puts("Welcome message sent successfully"); 
               
            //add new socket to array of sockets
            for (i = 0; i < max_clients; i++) 
            { 
                //if position is empty
                if( client_socket[i] == 0 ) 
                { 
                    client_socket[i] = new_socket; 
                    printf("Adding to list of sockets as %d\n" , i); 
                       
                    break; 
                } 
            } 
        } 
           
        //else its some IO operation on some other socket
        for (i = 0; i < max_clients; i++) 
        { 
            sd = client_socket[i]; 
               
            if (FD_ISSET( sd , &readfds)) 
            { 
                //Check if it was for closing , and also read the
                //incoming message
                if ((valread = read( sd , buffer, 1024)) == 0) 
                { 
                    //Somebody disconnected , get his details and print
                    getpeername(sd , (struct sockaddr*)&address , \
                        (socklen_t*)&addrlen); 
                    printf("Host disconnected , ip %s , port %d \n" ,
                          inet_ntoa(address.sin_addr) , ntohs(address.sin_port)); 
                       
                    //Close the socket and mark as 0 in list for reuse
                    close( sd ); 
                    client_socket[i] = 0; 
                } 
                   
                //Echo back the message that came in
                else
                { 
                    //set the string terminating NULL byte on the end
                    //of the data read
                    buffer[valread] = '\0'; 
                    send(sd , buffer , strlen(buffer) , 0 ); 
                } 
            } 
        } 
    } 
       
    return 0; 
} 

// g++ multiserver01.cpp -Wall -pedantic -std=c++11 -o multiserver01
// asiakas esimerkiksi: telnet localhost 8888 ?????

Ohjelma ei ole kovin pitkä, jos ei lakse mukaan kommenttirivejä. Sen voi kääntää ainakin komennolla

Koodia: [Valitse]

g++ multiserver.cpp -Wall -pedantic -std=c++11 -o multiserver01
(ohjelman nimi on tässä multiserver.cpp )

Sitten kokeilin sitä omalla koneella
 

Koodia: [Valitse]

telnet localhost 8888
komennoilla parissa uudessa samaan aikaan auki olevassa pääteikkunassa, ja näyttäisi toimivan sopivasti.

Olisiko tämä sellainen ohjelma, jonka asiakasmäärää voisi nostaa vaikka sataan tai tuhanteen, jos asikaalle menee yhdellä kyselyllä suunnilleen yksi rivi tietoa.

 

[matsukan]

Kannattaa tutusta myös Qt:n

Joitakin kirjastoja on olemassa, niistä myöhemmin.  Toisaalta web palvelinratkaisuja  on paljon markkinoilla ja kannattaa katsoa ensin voiko jokin olemassaoleva soveltua pohjaksi.

[nm]

Olisiko tämä sellainen ohjelma, jonka asiakasmäärää voisi nostaa vaikka sataan tai tuhanteen, jos asikaalle menee yhdellä kyselyllä suunnilleen yksi rivi tietoa.

Jos rajapinta tulee näkyviin nettiin, en suosittele palvelinsoftan koodaamista itse etenkään C:llä -- edes valmiisiin ohjeisiin perustuen. Turvallisessa sisäverkossa voi toki leikkiä millä haluaa.

[mrl586]

Jokin valmis palvelinohjelma kykenee hoitamaan tuon pyyntö- ja asiakasmäärän varsin helposti.
https://www.linux.com/news/which-light-weight-open-source-web-server-right-you