How To Get Gambas Web Started (1)
Introduction
Below is a brief tutorial on how to start and use a Gambas web site, the requirements and how to deploy the work you have done. Note that the
testing of the web page inside the IDE is not the same as when it is called from the browser, because the IDE, when executed, uses its own embedded web server with different variables (very different) in respect to a production server, and different from the interpreted code.
Use the directory of the project as the program to compile it and embed it in the "real" web server.
A gambas web (CGI) program is very simply made, it is just a piece of code like this:
Public Sub Main()
Response.Begin
Print "<h1>hola mundo</h1>"
Response.End
End
But this does not handle client requests (
Request class) just a simple static "hola mundo" using the
Response class to the web browser when the client (user) requests the CGI program code.
Illustrating the equivalents
The Gambas technology offers similar characteristics and features in a similar way to other technologies, let's see a comparison table of this:
|
Technology
|
Interpreted
|
Compiled
|
|---|
|
Gambas
|
gbs files (Gambas server pages)
|
gb programs (Gambas web component)
|
|
Java
|
jsp (Javas server pages)
|
servlets (Java Enterprise)
|
|
PhP
|
php/phtml (php-cgi/php-fpm)
|
N/A
|
|
.NET
|
asp (active server pages)
|
COM ( CLR runtime)
|
Preliminary concepts
Gambas web technology is provided to produce
web 2.0 ( dynamic and also interactive content).
There are two ways to produce and/or render html in dynamic or static web content: Interpreted and/or pre Compiled.
The web content is produced with the help of a web server, using always CGI, directly announcing the pre Compiled program or as wrapper to the Gambas interpreter through script code.
Independently of the way the server delivers the document web page, all the time the CGI concept is used.
What its CGI?: Common Gateway Interface (CGI) offers a standard protocol for web servers to execute programs like console applications (also called command-line interface programs) running on a server that generates web pages dynamically. Such programs are known as CGI scripts or simply as CGIs. The server determines how the script is executed by the server.
|
Interpreted (as script)
|
(Gambas server pages)
|
permits interpreted source files based on their content as script and will render html or not using logic, its only recommended for static content that only needs minimal logic, if it fails it shows the source code in the webserver, this must be configured using the cgi as wrapper that delivers the request to interpreter.
|
|
Precompiled (as cgi)
|
(Gambas web component)
|
permits compiling the program that will act as a cgi program and produces the html rendering. The ide component will install many of the necessary, but in server its not recommended, this must be configured as the handler of the request directly.
|
Requirements
First we need a web server, a Gambas IDE compiler and Gambas script interpreter, If you only make cgi's the scripter is unnecessary. The recommended install commands must be done on your servers system, open a console and switch to root to install the Gambas distribution program packages, the required web server packages and setup the cgi components in the web server.
Installation requirements
First: get Gambas! The easiest way is to install Gambas from your Linux distribution.
If Gambas is not yet contained in your distribution then download the distribution
from
http://gambas.sourceforge.net
Tip: If you have an ubuntu based web server you can use the PPA upgrade method to keep your gambas up to date with the latest version. See
Ubuntu for more info.
Second: understanding! We REALLY need to understand the concepts of
request Request and
response Response, it is
very much required to be familiar with this, HTTP is based on a request / response model, so there are two types of HTTP messages: the request and the response. The browser opens a connection to a server and makes a request. The server processes it, the
client "makes a request" and
webserver "returns a response"; so then data its sent and received using the two most commonly HTTP methods:
GET and
POST. Because Gambas is a RAD(Rapid Application Development) those concepts must be very clear for developing.
Last: get the environment! We need a webserver, that provides
true gci capabilities. Nginx does not provide real capabilities u will need further tuneups to properly configure it. As general further info for high end production environments, that must configure as a duple of a server front end that provides a proxy reverse to the real cgi webserver with the Gambas3 cgi program.
Feature Comparison Chart and Status
Starting to develop in Gambas we need a right direction point, so here we provide a quick chart to see supported features in respect to other technologies.
The development of web technologies has gained strength from about 3 years ago in the Gambas community of developers, having today even a
fully web graphical design component.
Here are not included the leaning curve because learn Basic its obviously more easy rather any other programing language, and Gambas are Basic like!
|
FEATURE
|
Gambas
|
Java
|
.NET
|
Python
|
Php
|
|---|
|
Based Coding Language
|
Basic
|
C++,C
|
Basic,C++
|
CPython,C
|
Perl,C
|
|
Backguard coding compatible
|
always
|
always
|
Breaking API each 4 years
|
Incompatible
|
always
|
|
Running On
|
Unix based
|
Any OS
|
Only MS based
|
Almost Any OS
|
Almost Any OS
|
|
Web server
|
Any cgi based
|
Tomcat, Jboss, Glassfish, Websphere, Weblogic
|
IIS
|
Apache2, IIS, Lightty, Hiawatta,Ngynx
|
Apache2, IIS, Lightty, Hiawatta,Ngynx
|
|
Runtime
|
Gambas Runtime
|
Java virtual Machine
|
Common Languaje Runtime
|
Python runtime
|
Zend Engine
|
|
Graphical Designer
|
Gambas IDE
|
Eclipse thirparty
|
.NET IDE
|
Not
|
Not
|
|
Web Components
|
gb.web, gb.http, gb.web.feed, gb.util.web, gb.curl
|
EJB, JSP, JSF, Spring, GWT
|
ASP, Spring, COM
|
Many
|
php-cgi, php-fpm, php-curl, php-sockets, more..
|
|
Web frameworks
|
Gambasforge
|
Spring, Struts, GWT
|
Buil-in
|
Django,CubicWeb
|
Codeigniter, Lavarel, Symphony
|
|
DBMS Data Access
|
ODBC, MySQL, SqLite, Postgres
|
JDBC: Oracle, Sybase, MSSQL, MySQL, Sqlite, DB2, etc
|
ADO.NET-oleDB, ODBC
|
PyODBC: ODBC
|
php-odbc, Php-pysql, php-sybase, php-pgsql, php-sqlite
|
|
DBMS Data Mapping
|
Jbsan MapBD
|
Hibernate, Dozer, Commons, Mapstruts, ModelMapper
|
ADO.NET
|
Django, Pandas
|
Codeigniter, Kohana, Doctrine
|
|
Web services
|
gb.xml
|
Build-in
|
Buil-in
|
Add-on (many)
|
php-soap, php-xml
|
|
Mobile native
|
not yet
|
Androit SDK
|
Xamarin(MOno)
|
Kivy, BeeWare
|
Not possible
|
|
Unit Tests
|
By own
|
JUnit
|
NUnit,MSUTF
|
PyUnit
|
PhpUnit
|
Starting coding
Gambas its a RAD software so lest assume will use the IDE, due you can always also use a normal text editor and then compile the cgi program by hand in console.
Start to code in IDE
When finished with the installation you can then use Gambas:
-
In a terminal window type "gambas3.gambas"
-
The Gambas IDE will open, select "New project...".
-
Select "Create a application web gb.web", click next,
-
Find a directory where to put the web project, click next,.
-
Enter a name for your web project, click OK.
-
Close the tips of the day window.
This starts with a main module that when built renders a page that prints out all the important values it needs to understand to manage web cgi's,
-
In the project window find the start button, press it (or press F5 key).
-
Then the default browser will be opened or a new tab and a web address from localhost will be displayed
this starts a local embedded webserver using a bind port 8080, displaying the server GCI standard values, those are very important to understand for high level production web pages.
Deploy the results
When the IDE runs its a local embedded server,
this is significantly different to how it runs on the server You must specify what its the "entry point" of the web application.
As a directory path root: All the cgi's will processed in the path, example: http://domain/thegcipath/
As a single entry: the cgi will be called directly by the request, example: http://domain/thegcipath/thecgiprogram
1) configuring CGI in webserver
On standard web server of providers web servers there's only two paths where the "produced program" (the Gambas compiled program u make) can be deployed, in the "/cgi-bin/" web path, and there's two only places for them, globally and per users, there's configurations for both cases:
|
Webserver
|
Initial/global configs
|
Per user configs
|
Script additions
|
module related
|
|---|
|
apache
|
ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
AddHandler cgi-script .cgi .sh .pl
|
<Directory "/home/*/public_html/cgi-bin/">
Options ExecCGI
SetHandler cgi-script
</Directory>
|
AddHandler cgi-script .gbs (*)
|
a2enmod cgi cgid alias userdir
|
|
lighttpd
|
$HTTP =~ "^/cgi-bin/" {
cgi.assign = ( "" => "" )
}
|
$HTTP =~ "^(/~[^/]+)?/cgi-bin/" {
cgi.assign = ("" => "")
}
|
cgi.assign = ("gbs" => "gbs3")
cgi.assign = ("gambas" => "gbr3")
|
lighty-enable-mod cgi alias userdir
|
(
) in apache there's still no way to workaround the interpreting of the scrips at the moment of writing this, it will try to execute anything.
2) Producing an deploying in webserver
-
In the IDE, go to project
-
Create-> executable
-
If you use the "per user configuration" choose the directory output as "public_html" under your home
-
Choose the name of the output program, by default "programname.gambas"
-
If the webserver only permits cgi's programs with .cgi extension put in second input: mv $(FILE) $(FILE).cgi
-
The cgi program now can be invoked from url http://localhost/~username/cgi-bin/programname.gambas.cgi
All of this its taking in consideration that inside your home, there's a "public_html" directory, used and handled by the webserver as per user web content, and also under this there's a "cgi-bin" directory, that its for cgi programs, and the webservers software are only apache2 or lighttpd.
See also