CODEWITHSUNDEEP
erlang
ceth
ceth

Reputation: 45295

erlang - startup script

To start my program I do the next sequence:

$ erl
> c(module1).
> c(module2).
> c(modulen).
modulen:start().

Is there any possibility to create script that allow me to launch my program ?

Upvotes: 10

Views: 7649

Answers (6)

Oleg
Oleg

Reputation: 11

In the home directory, create file .erlang

in that file write

compile:file(/path-to/module1).
compile:file(/path-to/module2).
compile:file(/edit-real-path-to/modulen). % etcetera; do not use c(module) inside this file!

then, if you need add (inside .erlang):

module1:start(). % etc

When you run erl (in the shell), the content of the .erlang (provided this file is in the home dir) will be executed at start (of the interpreter-erlang-VM you launch).

You can create .erlang file in some other (some 'current') directory, then, if you run erl (erlang interpreter) in that directory, that another .erlang will override the content of that .erlang in the home dir (of that which is like /home/your-user-name/.erlang ).

It is good idea to write inside of .erlang some reminder, like 

io:format(".erlang loaded-compiled module1!\n"). %etc

(as not to forget about that code which otherwise will be executed silently !)

(also, you can check, for this case, that e.g. module1 is indeed compiled and loaded after start, this or some similar way:

AllLoaded = code:all_loaded().
lists:filter(fun({Module,_})-> Module =:= module1 end, AllLoaded).

the answer should be like: [{module1,"/home/your-user-name/(path-to-your-code)/module1.beam"}] )

Upvotes: 1

Tristan Sloughter
Tristan Sloughter

Reputation: 326

Check out Sinan and Faxien: http://www.erlware.org

Upvotes: -1

ja.
ja.

Reputation: 1339

Two ways

precompile your code

$ erlc module1.erl
$ erl -s module1 funcname arg1 arg2 ....

Or use escript

#!/usr/bin/env escript
main() ->
    module1:fun(...)

escript is a scripting interface to Erlang

Upvotes: 2

jldupont
jldupont

Reputation: 96716

You could use a loader script that takes care of starting your application in an OTP fashion:

-module(XYZ_app).

-export([start/0]).

start() ->
    application:start(inets),
    application:start(XYZ).

You launch that script through a shell script. Beware of using escript if you plan on building daemons running at the OS boot time as they are tricky.

#!/bin/bash
erl -boot start_sasl -s XYZ_app start

Of course you need your XYZ.app file (just an example):

{application, tinycouch,
 [{description, "tinycouch"},
  {vsn, "0.1"},
  {modules, [
         tinycouch, tinycouch_app, tinycouch_sup,
         tinycouch_server, tinycouch_logger_h, tinycouch_utils,
         tinycouch_db, mod_tinycouch
        ]},
  {registered, [tinycouch
            ,tinycouch_server
            ,tinycouch_sup
           ]},
  {applications, [kernel, stdlib, sasl, inets]},
  {env, []},

  %% Application Start point
  {mod, {tinycouch_sup, []}}]}.

... and all your .erl files must have been compiled.

Note that if you intend to distribute your application (e.g. Debian repository etc), you probably should consider having a make file to compile and install your app.

As a final note: you could also go with a boot file (the ultimate OTP way) but I find those very constraining: a boot file ties your application to specific version release of Erlang (and other dependent applications). Your application might be able to run in various Erlang releases but you will need to have a separate build/release process for each "platform release" you intend to ship for.

Upvotes: 13

Christian
Christian

Reputation: 9486

You can use erl -make directly, as it assumes all *.erl files should be compiled to *.beam, and skip it if they haven't been changed since last compile. Check out the make module for what you can put in your Emakefile to change certain behavior.

Using plain Makefile to invoke this compile strategy also gives other users a familiar build-procedure.

Having a bootstrap start function as jldupont suggests is a nice way to start up your development environment. It is even sufficiently fine for using in production to some point.

The next step is to use full OTP (*.rel) release files and generate boot scripts that starts all the applications in the order the *.app specify dependencies on each other.

Upvotes: 1

Emil Ivanov
Emil Ivanov

Reputation: 37633

You can compile the modules with erlc

erlc module1 module2 module3

You can also create a script to run you program

#!/usr/bin/escript

main(_) ->
    modulen:start().

Then in the console:

chmod +x start.erl
./start.erl

Upvotes: 2

Related Questions