module network

gamnit :: network

Easy client/server logic for games and simple distributed applications

Both client and server can be used separately or together by importing network. Use both modules to create an program that discover local servers or create one if none is found:

redef fun handshake_app_name do return "network_test"

# Discover local servers
var servers = discover_local_servers
if servers.not_empty then
    # Try to connect to the first local server
    var server_info = servers.first
    var server = new RemoteServer(server_info)

    if not server.connect then
        print_error "Failed to connect to {server_info.address}:{server_info.port}"
    else if not server.handshake then
        print_error "Failed handshake with {server_info.address}:{server_info.port}"
    else
        # Connected!
        print "Connected to {server_info.address}:{server_info.port}"

        # Write something and close connection
        server.writer.serialize "hello server"
        server.socket.as(not null).close
    end
else
    # Create a local server
    var connect_port = 33729
    print "Launching server: connect on {connect_port}, discovery on {discovery_port}"
    var server = new Server(connect_port)

    # Don't loop if testing
    if "NIT_TESTING".environ == "true" then exit 0

    loop
        # Respond to discovery requests
        server.answer_discovery_requests

        # Accept new clients
        var new_clients = server.accept_clients
        for client in new_clients do
            # Read something and close connection
            assert client.reader.deserialize == "hello server"
            client.socket.close
        end
    end
end

All class definitions

package_diagram gamnit::network network gamnit::server server gamnit::network->gamnit::server gamnit::client client gamnit::network->gamnit::client gamnit::common common gamnit::server->gamnit::common gamnit::client->gamnit::common ...gamnit::common ... ...gamnit::common->gamnit::common a_star-m a_star-m a_star-m->gamnit::network

Ancestors

module abstract_collection

core :: abstract_collection

Abstract collection classes and services.
module abstract_text

core :: abstract_text

Abstract class for manipulation of sequences of characters
module array

core :: array

This module introduces the standard array structure.
module binary

binary :: binary

Read and write binary data with any Reader and Writer
module bitset

core :: bitset

Services to handle BitSet
module bytes

core :: bytes

Services for byte streams and arrays
module caching

serialization :: caching

Services for caching serialization engines
module circular_array

core :: circular_array

Efficient data structure to access both end of the sequence.
module codec_base

core :: codec_base

Base for codecs to use with streams
module codecs

core :: codecs

Group module for all codec-related manipulations
module collection

core :: collection

This module define several collection classes.
module common

gamnit :: common

Services common to the client and server modules
module core

core :: core

Standard classes and methods used by default by Nit programs and libraries.
module engine_tools

serialization :: engine_tools

Advanced services for serialization engines
module environ

core :: environ

Access to the environment variables of the process
module error

json :: error

Intro JsonParseError which is exposed by all JSON reading APIs
module error

core :: error

Standard error-management infrastructure.
module exec

core :: exec

Invocation and management of operating system sub-processes.
module ext

msgpack :: ext

Application specific MessagePack extension MsgPackExt
module file

core :: file

File manipulations (create, read, write, etc.)
module fixed_ints

core :: fixed_ints

Basic integers of fixed-precision
module fixed_ints_text

core :: fixed_ints_text

Text services to complement fixed_ints
module flat

core :: flat

All the array-based text representations
module gc

core :: gc

Access to the Nit internal garbage collection mechanism
module hash_collection

core :: hash_collection

Introduce HashMap and HashSet.
module inspect

serialization :: inspect

Refine Serializable::inspect to show more useful information
module iso8859_1

core :: iso8859_1

Codec for ISO8859-1 I/O
module json

json :: json

Read and write JSON formatted text using the standard serialization services
module kernel

core :: kernel

Most basic classes and methods.
module list

core :: list

This module handle double linked lists
module math

core :: math

Mathematical operations
module meta

meta :: meta

Simple user-defined meta-level to manipulate types of instances as object.
module msgpack

msgpack :: msgpack

MessagePack, an efficient binary serialization format
module native

core :: native

Native structures for text and bytes
module numeric

core :: numeric

Advanced services for Numeric types
module parser_base

parser_base :: parser_base

Simple base for hand-made parsers of all kinds
module poset

poset :: poset

Pre order sets and partial order set (ie hierarchies)
module protocol

core :: protocol

module queue

core :: queue

Queuing data structures and wrappers
module range

core :: range

Module for range of discrete objects.
module re

core :: re

Regular expression support for all services based on Pattern
module read

msgpack :: read

Low-level read MessagePack format from Reader streams
module ropes

core :: ropes

Tree-based representation of a String.
module safe

serialization :: safe

Services for safer deserialization engines
module serialization

serialization :: serialization

General serialization services
module serialization_common

msgpack :: serialization_common

Serialization services for serialization_write and serialization_read
module serialization_core

serialization :: serialization_core

Abstract services to serialize Nit objects to different formats
module serialization_read

json :: serialization_read

Services to read JSON: deserialize_json and JsonDeserializer
module serialization_read

msgpack :: serialization_read

Deserialize full Nit objects from MessagePack format
module serialization_write

msgpack :: serialization_write

Serialize full Nit objects to MessagePack format
module serialization_write

json :: serialization_write

Services to write Nit objects to JSON strings: serialize_to_json and JsonSerializer
module socket

socket :: socket

Socket services
module socket_c

socket :: socket_c

Low-level socket functionalities
module sorter

core :: sorter

This module contains classes used to compare things and sorts arrays.
module static

json :: static

Static interface to read Nit objects from JSON strings
module stream

core :: stream

Input and output streams of characters
module text

core :: text

All the classes and methods related to the manipulation of text entities
module time

core :: time

Management of time and dates
module union_find

core :: union_find

union–find algorithm using an efficient disjoint-set data structure
module utf8

core :: utf8

Codec for UTF-8 I/O
module write

msgpack :: write

Low-level write in MessagePack format to Writer streams

Parents

module client

gamnit :: client

Client-side network services for games and such
module server

gamnit :: server

Server-side network services for games and such

Children

module a_star-m

a_star-m

# Easy client/server logic for games and simple distributed applications
#
# Both `gamnit::client` and `gamnit::server` can be used separately or
# together by importing `gamnit::network`.
# Use both modules to create an program that discover local servers
# or create one if none is found:
#
# ~~~
# redef fun handshake_app_name do return "network_test"
#
# # Discover local servers
# var servers = discover_local_servers
# if servers.not_empty then
#     # Try to connect to the first local server
#     var server_info = servers.first
#     var server = new RemoteServer(server_info)
#
#     if not server.connect then
#         print_error "Failed to connect to {server_info.address}:{server_info.port}"
#     else if not server.handshake then
#         print_error "Failed handshake with {server_info.address}:{server_info.port}"
#     else
#         # Connected!
#         print "Connected to {server_info.address}:{server_info.port}"
#
#         # Write something and close connection
#         server.writer.serialize "hello server"
#         server.socket.as(not null).close
#     end
# else
#     # Create a local server
#     var connect_port = 33729
#     print "Launching server: connect on {connect_port}, discovery on {discovery_port}"
#     var server = new Server(connect_port)
#
#     # Don't loop if testing
#     if "NIT_TESTING".environ == "true" then exit 0
#
#     loop
#         # Respond to discovery requests
#         server.answer_discovery_requests
#
#         # Accept new clients
#         var new_clients = server.accept_clients
#         for client in new_clients do
#             # Read something and close connection
#             assert client.reader.deserialize == "hello server"
#             client.socket.close
#         end
#     end
# end
# ~~~
module network

import server
import client
lib/gamnit/network/network.nit:15,1--70,13
Nit tools. Version .