inets(3erl) [linux man page]

inets(3erl)						     Erlang Module Definition						       inets(3erl)

NAME

       inets - The inets services API

DESCRIPTION

       This module provides the most basic API to the clients and servers, that are part of the Inets application, such as start and stop.

COMMON DATA TYPES

       Type definitions that are used more than once in this module:

       service() = ftpc | tftp | httpc | httpd

       property() = atom()

EXPORTS

       services() -> [{Service, Pid}]

	      Types  Service = service()
		     Pid = pid()

	      Returns a list of currently running services.

   Note:
       Services started as stand_alone will not be listed.

       services_info() -> [{Service, Pid, Info}]

	      Types  Service = service()
		     Pid = pid()
		     Info = [{Option, Value}]
		     Option = property()
		     Value = term()

	      Returns  a  list of currently running services where each service is described by a [{Option, Value}] list. The information given in
	      the list is specific for each service and it is probable that each service will have its own info function that gives you even  more
	      details about the service.

       service_names() -> [Service]

	      Types  Service = service()

	      Returns a list of available service names.

       start() ->
       start(Type) -> ok | {error, Reason}

	      Types  Type = permanent | transient | temporary

	      Starts the Inets application. Default type is temporary. See also application(3erl)

       stop() -> ok

	      Stops the inets application. See also application(3erl)

       start(Service, ServiceConfig) -> {ok, Pid} | {error, Reason}
       start(Service, ServiceConfig, How) -> {ok, Pid} | {error, Reason}

	      Types  Service = service()
		     ServiceConfig = [{Option, Value}]
		     Option = property()
		     Value = term()
		     How = inets | stand_alone - default is inets

	      Dynamically starts an inets service after the inets application has been started.

   Note:
       Dynamically  started services will not be handled by application takeover and failover behavior when inets is run as a distributed applica-
       tion. Nor will they be automatically restarted when the inets application is restarted, but as long as the inets application is up and run-
       ning  they  will  be supervised and may be soft code upgraded. Services started as stand_alone , e.i. the service is not started as part of
       the inets application, will lose all OTP application benefits such as soft upgrade. The "stand_alone-service" will be linked to the process
       that  started  it. In most cases some of the supervision functionality will still be in place and in some sense the calling process has now
       become the top supervisor.

       stop(Service, Reference) -> ok | {error, Reason}

	      Types  Service = service() | stand_alone
		     Reference = pid() | term() - service specified reference
		     Reason = term()

	      Stops a started service of the inets application or takes down a "stand_alone-service" gracefully. When the  stand_alone	option	is
	      used in start, only the pid is a valid argument to stop.

SEE ALSO

       ftp(3erl) , httpc(3erl) , httpd(3erl) , tftp(3erl)

Ericsson AB							    inets 5.5.2 						       inets(3erl)

Check Out this Related Man Page

pg(3erl)						     Erlang Module Definition							  pg(3erl)

NAME

       pg - Distributed, Named Process Groups

DESCRIPTION

       This  (experimental)  module  implements process groups. A process group is a group of processes that can be accessed by a common name. For
       example, a group named foobar can include a set of processes as members of this group and they can be located on different nodes.

       When messages are sent to the named group, all members of the group receive the message. The messages are serialized.  If  the  process	P1
       sends  the message M1 to the group, and process P2 simultaneously sends message M2 , then all members of the group receive the two messages
       in the same order. If members of a group terminate, they are automatically removed from the group.

       This module is not complete. The module is inspired by the ISIS system and the causal order protocol of the  ISIS  system  should  also	be
       implemented. At the moment, all messages are serialized by sending them through a group master process.

EXPORTS

       create(PgName) -> ok | {error, Reason}

	      Types  PgName = term()
		     Reason = already_created | term()

	      Creates an empty group named PgName on the current node.

       create(PgName, Node) -> ok | {error, Reason}

	      Types  PgName = term()
		     Node = node()
		     Reason = already_created | term()

	      Creates an empty group named PgName on the node Node .

       join(PgName, Pid) -> Members

	      Types  PgName = term()
		     Pid = pid()
		     Members = [pid()]

	      Joins the pid Pid to the process group PgName . Returns a list of all old members of the group.

       send(PgName, Msg) -> void()

	      Types  PgName = Msg = term()

	      Sends the tuple {pg_message, From, PgName, Msg} to all members of the process group PgName .

	      Failure: {badarg, {PgName, Msg}} if PgName is not a process group (a globally registered name).

       esend(PgName, Msg) -> void()

	      Types  PgName = Msg = term()

	      Sends the tuple {pg_message, From, PgName, Msg} to all members of the process group PgName , except ourselves.

	      Failure: {badarg, {PgName, Msg}} if PgName is not a process group (a globally registered name).

       members(PgName) -> Members

	      Types  PgName = term()
		     Members = [pid()]

	      Returns a list of all members of the process group PgName .

Ericsson AB							   stdlib 1.17.3							  pg(3erl)

Linux and UNIX Man Pages

inets(3erl) [linux man page]

Check Out this Related Man Page