I was going through error log and saw this error in error log file. To solve this problem, In /etc/httpd/conf.d you will see a file entitled welcome.conf
It looks like this:
<LocationMatch “^/+$”>
Options -Indexes
ErrorDocument 403 /error/noindex.html
</LocationMatch>
Change it to this:
<LocationMatch “^/+$”>
Options Indexes
ErrorDocument 403 /error/noindex.html
</LocationMatch>
Just remove the hyppen(-) before the Indexes, that’s it. I hope this will solve your problem.
import java.io.*;
import java.net.URLDecoder;
import javax.servlet.*;
import javax.servlet.http.*;
/**
* Serving Image from Absolute Path.
*/
public class ImageServAbsolutePath extends HttpServlet {
private static final long serialVersionUID = 1L;
private static final int BUFFER_SIZE = 10240;
private String imagePath;
public void init() throws ServletException {
/*——- Image Base Path ———–*/
this.imagePath = “/images”;
}
protected void doGet(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException
{
// Get requested image by path info.
String requestedImage = req.getPathInfo();
// Check if file name is there in request URI.
if (requestedImage == null) {
// if file name is not there in request URI, send 404 Error, or show default image.
res.sendError(HttpServletResponse.SC_NOT_FOUND); // 404.
return;
}
// Decode the file name (might contain spaces and on) and prepare file object.
File image = new File(imagePath, URLDecoder.decode(requestedImage, “UTF-8″));
// Check if file actually exists in filesystem.
if (!image.exists()) {
// if file not exists in filesystem send 404 Error, or show default image.
res.sendError(HttpServletResponse.SC_NOT_FOUND); // 404.
return;
}
// Get content type of Image by filename.
String contType = getServletContext().getMimeType(image.getName());
// Check if file is actually an image.
if (contType == null || !contType.startsWith(“image”)) {
// if the file is not a real image send 404 Error, or show default image.
res.sendError(HttpServletResponse.SC_NOT_FOUND); // 404.
return;
}
// Reset servlet response.
res.reset();
res.setBufferSize(BUFFER_SIZE); //set buffer size
res.setHeader(“Content-Type”, contType); //set content type
res.setHeader(“Content-Length”, String.valueOf(image.length())); //set image size
res.setHeader(“Content-Disposition”, “inline; filename=\”" + image.getName() + “\”"); //set image name
// Create streams.
BufferedInputStream input = null;
BufferedOutputStream output = null;
try {
// Open streams.
input = new BufferedInputStream(new FileInputStream(image), BUFFER_SIZE);
output = new BufferedOutputStream(res.getOutputStream(), BUFFER_SIZE);
// Write image contents to response.
byte[] buffer = new byte[BUFFER_SIZE];
int length;
while ((length = input.read(buffer)) > 0) {
output.write(buffer, 0, length);
}
output.flush();
} finally {
if (output != null) {
try {
output.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (input != null) {
try {
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
Add the following entries to the web.xml file
<servlet>
<servlet-name>ImageServAbs</servlet-name>
<servlet-class>ImageServAbsolutePath</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>ImageServAbs</servlet-name>
<url-pattern>/image/*</url-pattern>
</servlet-mapping>
HOWTO USE :
<img src=”image/img.jpeg” />
This article contains step by step instructions for configuring an Apache 2.x web server which handles static content and delegates JSP (Java Server Pages) and Servlet requests to two Tomcat 4.x servers using AJP 13 connectors and a load balancing worker.
Apache 2.0 is a standards compliant, fast and mature web server which excels at delivering static content such as static HTML pages and images. The Tomcat web server is great for serving Java Server Pages and servlets, but it is not as fast as Apache for delivering static content.
In order to build a fast, scalable web application, the requirements call for an Apache server that delegates servicing of JSP and servlet requests to multiple tomcat servers by using an Apache module, mod_jk, that performs load balancing with session affinity, also known as “sticky” sessions.
Session affinity explained. When a client browser requests a JSP page for the first time, the load balancer redirects the request received by Apache to one of the two tomcat servers; further requests originating from the same client session will be automatically forwarded to the same tomcat server, so that the user’s session data is retrieved.
This document describes how I configured Apache 2.x to dispatch JSP and servlet requests to two Tomcat 4.x instances listening on different ports. This setup was done on a Linux system. Your mileage may vary.
<?
$dbconnection;
$table=”members”;
$csv = NULL;
/* link identifier from db connection */
$r = mysql_query(“SHOW COLUMNS FROM “.$table);
while ($row = mysql_fetch_assoc($r)) {
$csv .= $row['Field'].’,';
}
$csv = substr($csv, 0, -1).”n”;
$r = mysql_query(“SELECT * FROM “.$table);
while ($row = mysql_fetch_assoc($r)) {
$csv .= ‘”‘.join(‘”,”‘, str_replace(‘”‘, ‘”"‘, $row)).”"n”;
}
header(“Content-type: application/vnd.ms-excel”);
header(“Content-disposition: csv; filename=” . date(“Y-m-d”) .”_”.$table.”.csv; size=”.strlen($csv));
echo $csv;
exit;
?>
HOW TO Subversion+Apache on Fedora
To learn or use Subversion, please read the book.
To install subversion run below commands:
# yum install subversion
# yum install mod_dav_svn
Then you need to setup at least one repository to test it.
Here create the folders..
# mkdir /svn
# mkdir /svn/repos
# mkdir /svn/users
# mkdir /svn/permissions
repos – will contain all the projects
users – will contain all the user configs
permissions – will contain all the user permissions
We need to give these folders the proper permissions apache user permissions so that apache can write files on repos.
# chown -R apache.apache /svn
Then you can create repository using subversion cmd svnadmin.
# svnadmin create /svn/repos/project1
You can create multiple project repos under repos folder.
To setup apache server.
You may already have this subversion config file installed in conf.d folder otherwise you can create a new apache include file that will hold all configurations.
# vi /etc/httpd/conf.d/subversion.conf
This file need to contain something like this to serve the repository through apache:
LoadModule dav_svn_module modules/mod_dav_svn.so
LoadModule authz_svn_module modules/mod_authz_svn.so
<Location /svn/>
DAV svn
SVNPath /svn/repos
AuthType Basic
AuthName “Subversion Repository”
AuthUserFile /svn/users/passwords
Require valid-user
AuthzSVNAccessFile /svn/permissions/svnauthz.conf
</Location>
We need to create some files so that this config will work properly. The first is htpasswd file which will contain all the usernames nad passwords which i named “/svn/users/passwords”.
# htpasswd -cb /svn/users/passwords username password
Next you need to create the svnauth file.
# vi /svn/permissions/svnauthz.conf
Inside place a list of users who have access to files:
[/]
username = rw
The “rw” states that this user has read/write access to the root repository /.
Restart your web server and you should be done.
service httpd restart
Now you should access subversion repos as below.
http://www.websitename.com/svn/repos/
Apache HTTPD Virtual Hosts allow a single server to host many web sites with different addresses.
Virtual hosts are easy to set up, just check the documentation at http://httpd.apache.org/docs/ . That said, there are two main ways to configure virtual hosting, which you have to keep in mind when starting out. One method involves matching the request host name, IP address, port, or any combination of them to a separate block of HTTPD configuration statements. The other method specifies a directory pattern to use for the document root and cgi-bin based on parts of the host name.
For the former method of configuring virtual hosts, all one needs to do is add a wildcard ServerAlias directive to the VirtualHost block for your domain name.
<VirtualHost 1.2.3.4> ServerName domain.tld ServerAlias *.domain.tld DocumentRoot /var/www/ </VirtualHost>
For the latter, all one needs to do is match against only the domain name, or include subdomains in the pattern, making sure to create the appropriate directory structure.
VirtualDocumentRoot /var/www/%-2/ VirtualDocumentRoot /var/www/%-2/%-3/
Web hosts tend to use the larger VirtualHost method. Smaller shops, or generic mass hosts (departmental or employee hosting within an organization,for example) will find the latter very helpful, particularly when serving out of user’s home directories.
All this is great, but what about SSL? You could start up a separate instance of Apache HTTPD to serve over an SSL connection, but you probably don’t want to do that. There are some advantages, which but that is beyond the scope of this piece. The easiest way is to use a VirtualHost block to match against connections on port 443, the default HTTPS port. Contrary to popular belief, you do not need a separate IP address to do this.
<VirtualHost *:443> SSLEngine On SSLCertificateFile /etc/httpd/ssl.pem DocumentRoot /var/www/ </VirtualHost>
This works just fine if you are only serving one site over HTTPS. The problem comes in when you have multiple domain names being served from the same server which need SSL. Since the SSL certificate needs to be used before the web browser sends a request to the server, the server has no way of picking a domain-specific SSL certificate to use. Name-based matching just won’t work for SSL. This is why proprietors of shared web hosting services demand that you purchase a dedicated IP address if you want to use SSL. IP addresses are known before SSL certificates are used, so by matching based on IP address, we can use domain-specific SSL certificates.
<VirtualHost 1.2.3.4:443> SSLEngine On SSLCertificateFile /etc/httpd/dom1-ssl.pem DocumentRoot /var/www/dom1/ </VirtualHost> <VirtualHost 1.2.3.5:443> SSLEngine On SSLCertificateFile /etc/httpd/dom2-ssl.pem DocumentRoot /var/www/dom2/ </VirtualHost>
So, to recap, you do not need a separate IP address to use HTTPS. You do need separate IP addresses to use HTTPS on servers with multiple domains using SSL.
This FlashGuideTM covers integrating Apache 1.3.x and Tomcat 4.x on Unix via mod_jk. These instructions have been tested on SuSE 9.0, Red Hat 6.2 and Fedora Core 2. There are two ways to integrate Apache and Tomcat: mod_jk and mod_jk2. Mod_jk is the older but more stable version, which supports load balancing and non-standard web application locations. Mod_jk2 is newer, has bugs, and, as of 11/15/04, is no longer being actively developed.
These instructions are for the current version of Tomcat 4.1.31, but have worked the same for all previous versions of Tomcat.
If you are using an older version of Tomcat, note that there are known bugs when using mod_jk and Tomcat 4.0.1 or 4.0.2, so you must use 4.0.3 or greater.
1. Building Apache 1.3.x on Linux
Unless you can find a binary distribution of Apache with DSO support enabled, you will have to follow these instructions to build it yourself.
1. Check your prerequisites:
1. You will need GCC installed
2. You will need /usr/ccs/bin and the gcc executables in your $PATH
2. Download the latest Apache source from http://httpd.apache.org/download.cgi – currently, the latest is 1.3.33.
3. Unpack the distribution into a development directory (I used /usr/local)
The distribution directory will be something like apache_1.3.33
4. Cd into the distribution directory (e.g. /usr/local/apache_1.3.33)
5. Configure the makefile:
./configure –with-layout=Apache –prefix=/usr/local/apache –enable-rule=SHARED_CORE –enable-module=so
Apache 2.0 was running on several Linux boxes behind a load balancer. If you ran top on each box, the CPU was mostly idle, there was plenty of memory available, and yet Apache seemed sluggish. Here are a couple of things I did to speed things up.
1. Disable RedirectMatch directives temporarily
All the Apache servers had directives such as:
RedirectMatch /abc/xyz/data http://admin.mysite.com/abc/xyz/data
This was done so administrators who visited a special URL would be redirected to a special-purpose admin server. Since the servers were pretty much serving static pages, and they were under considerable load due to a special event, I disabled the RedirectMatch directives temporarily, for the duration of the event. Result? Apache was a lot faster.
2. Increase MaxClients and ServerLimit
This is a well-known Apache performance optimization tip. Its effect is to increase the number of httpd processes available to service the HTTP requests.
The 2 entries I had in httpd.conf in the IfModule prefork.c section were:
MaxClients 1000
ServerLimit 1000
Now I have a procedure for tuning the number of httpd processes on a given box:
1. Start small, with the default MaxClients (150).
2. If Apache seems sluggish, start increasing both MaxClients and ServerLimit; restart httpd every time you do this.
3. Monitor the number of httpd processes; you can use something like:
ps -def | grep httpd | grep -v grep | wc -l
If the number of httpd processes becomes equal to the MaxClients limit you specified in httpd.conf, check your CPU and memory (via top or vmstat). If the system is not yet overloaded, go to step 2. If the system is overloaded, it’s time to put another server in the server farm behind the load balancer.
WARNING: MaxClients of 1000 exceeds ServerLimit value of 256 servers, lowering MaxClients to 256. To increase, please see the ServerLimit directive.
To avoid above warning, You need to put the Serverlimit option before the maxclient in the apache config file.
Example config:
IfModule prefork.c
StartServers 20
MinSpareServers 5
MaxSpareServers 20
ServerLimit 1024 <====—— moved this line here rather than after the
Maxclients (otherwise Apache will gives error, “WARNING: MaxClients of 1000
exceeds ServerLimit value of 256 servers, lowering MaxClients to 256. To
increase, please see the ServerLimit directive”)
MaxClients 512 <====——– changed from 256 to 512
MaxRequestsPerChild 10000
IfModule
Apache 2.x is designed to balance flexibility, performance and portability. Apache is a good all-purpose webserver. Since Apache is designed to fit most scenarios it hasn’t been optimized to set any kind of speed records, but Apache 2.x is capable of high performance.
There have been many improvements made in Apache 2.x and many are enabled by default. But, there are some changes you can make at compile-time and run-time that can positively affect performance.
Ram is the single biggest hardware issue that determines webserver performance, so the more the better. Once a server runs out of memory it starts using the swap space on the hard drive. You never ever want have to the web server use swap. Using swap slows down of each request to such slow speeds which causes users to hit “reload”, which increases the work swap has to do, slowing it further.
So I always recommend putting in as much ram as your server can hold.
The rest of the hardware is up to you: get a fast CPU, a fast network card, and fast hard drives, you’ll have to figure out what is fast enough for you based on needs, availability and price.
You can counter, and should, control the MaxClients setting so that your server does not spawn so many children it starts swapping. This procedure for doing this is simple: determine the size of your average Apache process, by looking at your process list via a tool such as top, and divide this into your total available memory, leaving some room for other processes.
This is a guide on setting up Tomcat to do virtual hosting and make it behave like a simple webserver with jsp and servlet support, for many different sites all hosted on the same IP address. The aim is to have a single directory for each virtual host, which can be manipulated individually without hassles from managing multiple .war files and other configuration difficulties.
To configure Tomcat for a virtual host, you need a directive in the server.xml file, and a ROOT.xml file in the conf/Catalina/$host directory. Here’s the minimal setup required for a copy of Tomcat serving directly on Port 80, using no connectors or other configuration difficulties.
This was written for Tomcat 5 on linux, with Tomcat installed in /usr/local/tomcat
We start with the simplest configuration, of one website, called ‘localhost’ which keeps it’s files in /usr/local/tomcat/webapps/localhost . We’re not using any .war files here – all the files are placed straight into the directory.
TechiePark JavaFundamentals Consumer Admanya Cafe Admanya CoreJavaTechTips
