ITA NETWORK SOLUTIONS
JSP Web Hosting & Domains
Private Tomcat JVM hosting solutions.
Best price for JSP hosting with PHP support.
Private Tomcat JVM hosting solutions.
Best price for JSP hosting with PHP support.
Listed below, you can find our awsome web hosting packages provided with care and passion!
If you are looking for premium quality web hosting package for your website, you are at the right place!
We offer outstanding user friendly web hosting packages for all!
Low cost shared web hosting
Secured servers and free SSL for your web site
You can transfer your domain for free with our hosting plans
You do not have to worry about the traffic you will be using
Our support staff is available 24/7/365 to assist you
Plesk - the best control panel + APS auto installer with more than 400 scripts and more than 1000 PHP classes
Features common to all web hosting packages.
A web hosting service is a type of Internet hosting service that allows individuals and organizations to make their website accessible via the World Wide Web.
We offer shared Plesk web hosting services. Plesk is the best control panel for web hosting automation with many features. You don't need to be website administrator to manage your site.
Shared web hosting service is a web hosting service where many websites reside on one web server connected to the Internet. This is generally the most economical option for hosting, as the overall cost of server maintenance is amortized over many customers.
Reseller hosting services for web studios and web hosting resellers.
Reseller hosting accounts where you can order space and get unlimited customers and Plesk accounts. You can setup your own web hosting plans for your customers. This reseller hosting solutions is the best choice for web studios and web developers that manage the customer's websites and pay the renew fees with profit.
Java hosting service on shared servers in order to provide the most economical Java hosting solution for our customers. We offer latest Java hosting environment together with the best hosting control panel Plesk. The Java extension for Plesk is developed by own team of Java experts and offers the best Java hosting experience that you can get!
Tomcat hosting service on shared servers. You can easily deploy and reload your applications. The shared Tomcat hosting solution that we provide is the best option for low cost Java & JSP applications. The Plesk control panel offers many more features. The Tomcat hosting extension is integrated in Plesk and you have full control over your applications and Tomcat logs. Spring & Hibernate are supported in our Tomcat hosting environment.
JSP Hosting on Linux Servers.
JavaServer Pages (JSP) is a technology that helps software developers create dynamically generated web pages based on HTML, XML, or other document types. Released in 1999 by Sun Microsystems, JSP is similar to PHP and ASP, but it uses the Java programming language.
To deploy and run JavaServer Pages, a compatible web server with a servlet container, such as Apache Tomcat or Jetty, is required.
Architecturally, JSP may be viewed as a high-level abstraction of Java servlets. JSPs are translated into servlets at runtime, therefore JSP is a Servlet; each JSP servlet is cached and re-used until the original JSP is modified.
JSP can be used independently or as the view component of a server-side model–view–controller design, normally with JavaBeans as the model and Java servlets (or a framework such as Apache Struts) as the controller. This is a type of Model 2 architecture.
JSP allows Java code and certain pre-defined actions to be interleaved with static web markup content, such as HTML, with the resulting page being compiled and executed on the server to deliver a document. The compiled pages, as well as any dependent Java libraries, contain Java bytecode rather than machine code. Like any other Java program, they must be executed within a Java virtual machine (JVM) that interacts with the server's host operating system to provide an abstract, platform-neutral environment.
JSPs are usually used to deliver HTML and XML documents, but through the use of OutputStream, they can deliver other types of data as well.
The Web container creates JSP implicit objects like request, response, session, application, config, page, pageContext, out and exception. JSP Engine creates these objects during translation phase.
The subscription's hosting plan comes with a defined memory limit. Your software must be able to fit within this limit. If you find that the limit is too low you can upgrade to a plan with more memory.
Please note that it is likely that some hosting plans do not include any memory for MyAppServer at all. Thus it can NOT be used on such plans.
START - The service must be able to start within 90 seconds.
STOP - The service must be able to stop within 60 seconds.
The service can be started at most 3 times within 10 minutes. Subsequent attempts to start it in this interval will put it in failed state. Once the interval passes it can be started again.
This limit is imposed in order to prevent a failing service to consume excessive system resources(CPU/Memory/IO).
Network bandwidth is typically not limited. If an excessive use is observed though we might be forced to impose some limits. This won't happen without a notification to you though.
Some external connections might be blocked by a firewall. E.g. SMTP connections to external hosts are not allowed in an attempt to prevent spamming. Outgoing mail should be routed via the local mail queue.
Limits might be imposed on some other resources too. E.g.:
Please also consult the "Acceptable Use Policy" and "Terms of Service" of the service which you have subscribed to.
Some limits might be defined there which your service running via MyAppServer should/must comply.
We might be able to help you. E.g.:
Just open a trouble ticket and we will tell you if your demand can be fulfilled. There is no guarantee though.
In order to run your custom application server you should:
bin/start
and bin/stop
scripts. Replace those with a modified version which suits your needs. Search for "bin/" in this doc for additional information.If a new stable version of a JVM or an AppServer ( the product should be available in the dropdowns ) has been released you might open a ticket and our admins can make it available for easy installation via this interface.
MyAppServer allows you to create a service for your software which is registered with the operating system service supervisor (SystemD).
Once created this service can be controlled by yourself. You can start/stop/restart it or send a TERM/KILL signal to its process group.
If your service exits My App Server has configured SystemD to restart it, no matter what the exit reason is:
Once started the service is constantly monitored.
E.g. in the default configuration HTTP requests are sent to each of the configured domains landing pages. If any of the requests fails the service is restarted.
Also, if the service fails to send a READY notification within a configured start timeout it is also considered as failed and a restart is tried.
To disable the service monitoring you can:
# Only do a "connect" check to the AJP port:
echo '[{"name":"CONNECT"}]' > my_appserv/envdir/MAS_WD_VHOSTS
# Do not do any checks, even the connect . Only send READY and KEEP-ALIVE signals to SystemD:
echo '[]' > my_appserv/envdir/MAS_WD_VHOSTS
Note that you can also make changes to the WatchDog or completely replace it with your own implementation if your service requires it.
The service runs with the privileges of your system user. This means that it has full access to all the resources in your web hosting account - files, databases, network connections, mailboxes, etc.
A private dedicated IP address is allocated to your service. Thus it can accept connections to any Network port that is available to your system user.
Under Linux, ports 1-1024 are typically reserved for privileged users. The rest are available for your use. It is guaranteed that the whole range of ports ( 1024 - 65536 ) is available for your use (TCP, UDP, etc.).
The following section is specific for "Apache Tomcat".
The provided Tomcat versions are the stock ones - these are the ones available from the official Apache Tomcat website.
The modifications which are made to them are only in the config files:
conf/context.xml
conf/logging.properties
conf/server.xml
If a file is modified the original are kept with an .orig
extension, e.g. conf/server.xml.orig
. This is done in order the changes to be easily trackable by you or an operator.
There are pre-configured Tomcat versions which can be chosen when initializing the MyAppServer service.
If you need you can run any Tomcat version. If the required version is not already available on your hosting server you can upload it.
Note: It is a good idea to stop the service before changing the versions.
When you initialize the service with JVM/Tomcat versions from the dropdowns a directory structure like the following is created for you:
my_appserv/apache-tomcat-9.0.41/
my_appserv/default -> apache-tomcat-9.0.41
Here default
is a symlink to apache-tomcat-9.0.41. To run a custom Tomcat version you can create a structure like this:
my_appserv/apache-tomcat-9.0.41/
my_appserv/apache-tomcat-10.0.3/
my_appserv/default -> apache-tomcat-10.0.3
In this example the old Tomcat version is kept and the default
symlink is repointed to the new version.
Note that the stock service start/stop
scripts might not work with some Tomcat versions. These startup/shutdown scripts are also symlinks:
my_appserv/bin/start -> /scm/plesk-myappserv/bin/user-start.sh
my_appserv/bin/stop -> /scm/plesk-myappserv/bin/user-stop.sh
If they don't work for some reason you can replace the symlinks with your custom start/stop
scripts. Make sure to look at what the stock ones do though, as it might be a good idea to base your modifications on them. E.g. the default bin/start
:
conf/server.xml.lhs_generated
As you might have already guessed - all custom modifications to Tomcat are allowed. E.g. you can:
lib
directory if this is required (e.g. by your DB connection pooling code, resource definitions, etc. ),When initializing the service via the dropdowns Tomcat is pre-configured like this:
conf/server.xml -> server.xml.lhs_generated
conf/server.xml.lhs_generated
The bin/start
script generates the file server.xml.lhs_generated
which is based on the domains with activated MyAppServer support and the applications which are found in their directory structure.
If you need you can replace the conf/server.xml
symlink with the modified server.xml
which you need.
There are pre-configured JVM versions which can be chosen when initializing the MyAppServer service. Your Tomcat instance is then pre-configured to use the chosen JVM version.
If you need though you can run any JVM version. If it is not available on your hosting server you can upload it and edit the following files:
my_appserv/envdir/JAVA_HOME
my_appserv/envdir/JAVA_OPTS
These are symlinks by default, so you might need to remove them and create new files on their place.
Make sure to specify the full(absolute) path to the JVM, not a relative one.
You can upload your own JVM and modify it as needed.
Modifications to the global JVMs ( those pre-installed on the server ) are not allowed.
Please note that some modifications might by denied by law - e.g. use of strong cryptography is not allowed in some countries. It is up-to you to obey such restrictions.
You can run any number of Java web apps that you like.
All Java frameworks can be used and are supported.
What this service offers can be considered a Private JVM or Private Tomcat . It actually offers more than what others include in these terms as My App Server is designed to be very flexible and can run anything, not just predefined versions of JVM/Tomcat .
Tomcat's security manager is NOT enabled in the default configuration as its default security policy imposes some restrictions which prevent some applications from working correctly.
If you application recommends using a security manager you can enable it and customize the security policy.
Tomcat calls the root directory of a domain or subdomain "application base" ( appBase
config option of a Host element in server.xml
).
Apache HTTPd calls it "document root" ( DocumentRoot
config option ).
In the default configuration of My App Server Tomcat and Apache HTTPd virtual hosts are pointed to the same directory so DocumentRoot
and appBase
are the same thing.
Note: This description is for the unmodified configuration of My App Server. You are free to modify the service as needed.
Tomcat web apps should you placed directly in the DocumentRoot
.
For the main domain of a subscription the DocumentRoot
is pointed to the /httpdocs
directory by default.
Here's an example.
Let's say that you have a docs.mydomain.com subdomain pointed to the /docs
directory with the following structure:
With this layout the following application contexts will be created:
Each Tomcat context represents a separate web app with its own classes, libraries, JSP files, etc. E.g:
Note: This description is for the unmodified configuration of My App Server. You are free to modify the service as needed.
The default scanner creates a new Context
for each directory that:
DocumentRoot
( first level child of DocumentRoot
)WEB-INF
An example has been provided in the sections above.
These are not enabled by default.
If you need them you can enable them by either:
server.xml
orYou might need to make some changes to the app config files also. E.g. the login credentials in conf/tomcat_users.xml
and access limits in the app's META-INF/context.xml
. The required changes depend on the chosen Tomcat version and the shipped version of the app.
WAR stands for Web application ARchive .
WAR files must be extracted in order to be deployed. E.g. the contents of test.war
should be placed in a directory named test
.
Note: This description is for the unmodified configuration of My App Server. You are free to modify the service as needed.
You can provide a custom server.xml
to support deployments from WAR files.
While Tomcat can run an app directly from a WAR without unpacking it we strongly advise against such configuration as it is very likely that it will lead to a vastly degraded performance.
Tomcat can auto extract your WARs if you set unpackWARs="true"
for the respective Host
.
Each Host
element in Tomcat's server.xml
config file is configured like this by default:
deployXML="true" - customizations in META-INF/context.xml are supported
deployOnStartup="false" - Do not do application discovery on startup. Only apps configured in server.xml are deployed.
autoDeploy="false" - No deployment of new apps placed in appBase while Tomcat is running.
unpackWARs="false" - Do not extract WAR files automatically
This are settings which are suitable for production use.
As already mentioned you can provide your own server.xml
if e.g. you insist on deploying from WAR files.
Tomcat logs can be found in my_appserv/default/logs
directory:
catalina.out - STDOUT & STDERR of the start script are redirected to this log
catalina.stop - STDOUT & STDERR of the stop script are redirected to this log
watchdog.log - STDOUT & STDERR of the WatchDog are redirected to this log
Note: This description is for the unmodified configuration of My App Server. You are free to modify the service as needed.
If you upload your application while the service is running its contents might be available via the ROOT context.
Note: This description is for the unmodified configuration of My App Server. You are free to modify the service as needed.
Tomcat might pick some changes automatically. E.g. new or updated JSP or class files. It usually decides which files have been updated by checking their modified time . E.g. if a JSP page has a newer modified time than its corresponding pre-compiled class file Tomcat re-compiles it.
If some changes are not picked up you might need to restart the service.
Note that some changes might be ignored even on Tomcat restart. If this happens to you you might want to switch on the option "Clean work directory on service start" and retry the restart.
When a My App Server support is switched on for a domain, custom rules are added to the Apache HTTPd frontend to pass all the requests to JSP files to the backend server via the AJP protocol.
Typical web applications require additional mappings though. E.g. mappings for Servlets or Filters.
In order your app mappings to work as expected two things must be done:
WEB-INF/web.xml
or via an annotation )The second step is done via .htaccess
files. Here's an example. Let's say you have the following context:
http://docs.mydomain.com/app1/
and this web app has:
/docs/app1/WEB-INF/web.xml
which contains:
<servlet-mapping>
<servlet-name>MyServlet</servlet-name>
<url-pattern>/myservlet/action1</url-pattern>
</servlet-mapping>
You have to create the file:
/docs/.htaccess
which contains:
RewriteEngine On
RewriteRule ^app1/myservlet/action1$ ajp://mas-YOUR_SYS_USERNAME/app1/myservlet/action1 [NE,P,L]
You can also map all requests for the app1
web app to Tomcat like this:
RewriteEngine On
RewriteRule ^app1/(.*)$ ajp://mas-YOUR_SYS_USERNAME/app1/$1 [NE,P,L]
Or you can even forward all requests for this subdomain to the Tomcat backend:
RewriteEngine On
RewriteRule ^(.*)$ ajp://mas-YOUR_SYS_USERNAME/$1 [NE,P,L]
You should be extra carefull when using relative paths. They can be relative to something different than what you expect.
In order to check a relative path you can place a code like this in e.g. test.jsp
:
<%@page contentType="text/plain; charset=UTF-8" pageEncoding="UTF-8"%>
<%
java.io.File f = new java.io.File(".");
out.println( "path: " + f.getAbsolutePath() );
%>
The directories which you see when you login via FTP or in the Plesk File manager are relative to the subscription home dir.
Here's an example of an absolute path:
/var/www/vhosts/mydomain.com/docs/WEB-INF/uploads/file1.txt
If you encounter:
java.security.AccessControlException: access denied (java.io.FilePermission /SOME/PATH)
the usual causes are:
A file or directory can have the required read/write/execute permissions removed.
You can manage permissions via Plesk File Manager or the chmod
command.
In order to send mail from your Tomcat web app you can use the following settings:
Hostname: localhost
TCP port: 25
Username: [email protected]
Password: mailbox's password
You might need to place mail.jar
and activation.jar
in your webapp's WEB-INF/lib
depending on the mail API implementation that you use.
Here's an example for MySQL which you can place in e.g. test.jsp
:
<%@page language="java" import="java.sql.*" contentType="text/plain; charset=UTF-8" pageEncoding="UTF-8"%>
<%
Class.forName( "com.mysql.jdbc.Driver" );
java.sql.Connection con = DriverManager.getConnection(
"jdbc:mysql://localhost/DBNAME",
"USERNAME",
"PASSWORD"
);
out.println( con.toString() );
%>
The MySQL driver should be placed in your webapp's WEB-INF/lib
.
We do not recommend using connection pooling in our environment since the connection establishment to the DB is very lightweight process.
Just close the DB connections when you're finished with them and reopen them when needed.
A request scope is an excellent lifespan for a DB connection.
Be especially careful when reusing pooled connections since the RDBMS might be configured to timeout inactive connections and you might encounter:
java.sql.SQLException: No operations allowed after connection closed
"My Application Server" allows you to run your own backend application server (a daemon process) on the web hosting hardware.
E.g. (just on the Java side) you can run:
and more.
Node.js (JavaScript) and Phusion Passenger (Python, Ruby and more) are also supported by this control panel via different extensions, but you can run them via MyAppServer too.
Strictly speaking - MyAppServer allows you to run any long running program that is supported on the server hardware and the running Linux kernel. Yes, this means that you can run a program written in any language, either compiled (e.g. C/C++) or interpreted (e.g. PHP, Perl, Python) with or without a virtual machine (e.g. JVM).
If this option is enabled the service will be started on server reboot.
If this option is enabled the default start
script will remove default/work/*
If this option is enabled the default start
script will remove default/logs/*
The START action attempts to start the service.
SystemD waits for a READY notification in order to consider the service started.
The default WatchDog configuration sends the READY signal when the landing pages of all the configured domains start to return non-error HTTP status codes.
See the rest of this documentation for ways to override the WatchDog behavior.
The START action executes my_appserv/bin/start
. It can be changed to fit your service needs. Search for "bin/start" in this doc for more info.
See Limits for Start/Stop timeouts.
The STOP action attempts to stop the service gracefully. It waits for the main process of the service to exit.
In case that the stop command timeouts SystemD sends TERM & CONT
signals to all the processes in the service group.
If there are remaining processes after the TERM
signal the processes are killed with KILL & CONT
signals . The KILL
signal is non maskable and the Linux Kernel terminates processes which receive it. There are some very specific cases in which blocked processes can not be killed even with a KILL
signal.
The STOP action executes my_appserv/bin/stop
. It can be changed to fit your service needs. Search for "bin/stop" in this doc for more info.
See Limits for Start/Stop timeouts.
RESTART does a STOP followed by a START, so the descriptions of those two apply.
RELOAD usually does a configuration reload without restarting the whole daemon process.
This action is not implemented in the default scripts since Tomcat does not support a reload operation. So it is normal to fail if you execute it.
If your custom application server supports the reload operation you can create a bin/reload
script which will be executed when this action is triggered. It is up-to you to decide what to do with this action.
Those allow to send the signals to all the processes in the service group. Those signals usually TERMinate or KILL the service.
Normally, those two actions should not be used.
Note that SystemD will restart the service if you kill it with one of those signals while it was in active state.
This action creates the my_appserv
directory structure when it is missing. The directory structure will be initialized with the chosen Application server and JVM versions .
A domain/subdomains can have My App Server support activated/deactivated if it:
This active/disabled state is used in the default configuration:
bin/start
script to generate the needed configuration filesIf you run a customized version of an application server or have modified the default start/stop/watchdog scripts you are free to ignore the activation status. E.g. you can have a default catchall VHost configured on the backend.
my_appserv
directory structureNote: If you have made some modifications under my_appserv
, e.g.:
remember to keep the modified files somewhere BEFORE deleting the my_appserv
directory tree.
Note: Your applications and files are kept outside of my_appserv
directory tree in My App Server default configuration. Thus removing my_appserv
directory will not remove your data. Consider your changes if you have made modifications to the default configs.
Note: It is also possible that some applications are integrated with the application server and are storing data under its directory structure. Consider this BEFORE removing my_appserv
directory tree.
This service accepts connections on a private interface only. Thus it can not be directly contacted by external hosts.
Typically a frontend web server ( Apache HTTPd ) is configured to pass the required requests to the backend.
The frontend might handle some of the requests that it receives on its own. E.g. requests for:
mod_php
)and pass other requests to different backends. E.g certain parts of the URL space might be mapped to:
See the section Servlet/filter mappings for an example on how to define the needed proxying rules .
My App Server offers a production environment for hosting your services.
Development and testing should be done locally, not on this service.
See Restart Limits for some restrictions which apply.
JsPHP is a cross-browser JavaScript library designed to make the PHP application programming interface (API) available in JavaScript environments.
JsPHP HostingSub-domains Hosting on Linux Servers.
Sub-domains HostingThe PHP Smart.Framework (smart framework php) is a free, BSD licensed, open-source web framework that claims to fit small, medium as well as large web projects.
Smart.Framework HostingRialto (Rich Internet Application Toolkit) is a cross browser Ajax-based JavaScript widgets library.
Rialto Toolkit HostingRedaxscript is an ultra lightweight website engine, simplifying the world of complex online projects.
Redaxscript HostingeXo Platform is an open source, standard-based, Enterprise Social Collaboration Platform written in Java.
eXo Platform HostingLiferay makes software that helps companies create digital experiences on web, mobile and connected devices.
Liferay HostingJava Hosting packages on Linux servers.
Java HostingTomcat Hosting on Linux Servers.
Tomcat HostingApache Roller is a Java-based Open Source "full-featured, Multi-blog, Multi-user, and group-blog server suitable for blog sites large and small".
Apache Roller HostingPrivate JVM hosting with pre-installed Tomcat server.
Private JVM HostingMagnolia is an open-source digital business platform with a content management system (CMS) at its core.
Magnolia HostingOpenKM is a Free/Libre document management system that provides a web interface for managing arbitrary files.
OpenKM HostingAdult Java Hosting packages on Linux Servers.
Adult Java HostingHippo CMS is an open-source, dual licensed, Content Management System.
Hippo CMS Hosting