AndyVentures: Summer Has Gone And All I Got Was This Popcorn

Summer Has Gone And All I Got Was This Popcorn Kernal Stuck In My Teeth. So I know that summer actually ended sometime in the middle of August (and yes, I'm too lazy to look up when it actually ended) – but it sure as hell doesn't feel


AndyVentures – http://www.andyfields.net/

www.centos.org – Forums – CentOS 5 – Networking Support – can't

Im using x86_32 kernal,only kvpnc and vpnc for me by yum. And I need to connect to vpn server built by Windows 2003. So vpnc_i386 cannt be used. And I dont use KDE , could I use kvpnc???????? Can tell me how can I do for connect to my


www.centos.org :: Forum – http://www.centos.org/

WordPress (Version 2.8.1) Released

The latest stable release of WordPress (Version 2.8.1) is available in two formats from the links to your right. If you have no idea what to do with this download, we recommend signing up with one of our web hosting partners that offers a one click install of WordPress or getting a free account on WordPress.com.

What’s Next?

With our famous 5-minute installation, setting up WordPress for the first time is simple. We’ve created a handy guide to see you through the installation process. If you’re upgrading your existing installation, we’ve got a guide for that, too. And should you run into any trouble along the way, our support forums are a great resource, where seasoned WordPress experts volunteer their time to help you get the most out of your blog.

TYPO3 CMS

TYPO3 is a free Open Source content management system for enterprise purposes on the web and in intranets. It offers full flexibility and extendability while featuring an accomplished set of ready-made interfaces, functions and modules

The TYPO3 Association has released a new version of their very successful open source project. TYPO3 has been downloaded over 3.000.000 times from Sourceforge.org which makes it one of the World’s leading Enterprise Open Source products.

 The main focus of the new 4.2 version is improving usability, but there are also many enhancements for system administrators and developers. Including bug fixes, there are nearly 650 enhancements in TYPO3 4.2.
Read more…

On the Road with the Google Maps API

In the previous installment of this occasional series discussing the Google Maps API, we used the API and a PHP library named GoogleMapAPI to plot and calculate a route along a map. Uses for such a feature are many, among them determining distance as the crow flies between two points, and even a quick gauge for figuring the length of a simple jogging or bicycling route. However, although useful, the limitations of such a feature quickly become apparent when the need arises to calculate the distance of a more complex route. Or what if you needed to chart a much longer route, such as one which would take the user from Columbus, Ohio to Cleveland, Ohio? For instance, charting the route as accurately as shown in Figure 1 would likely prove fairly tedious using this approach.

Figure 1. Charting a complex route
Figure 1. Charting a complex route

Thankfully, the Google Maps API offers a feature which can greatly reduce the work involved in creating complex routes such as this. In fact, you’ll be able to use this feature to create a complex multi-point route simply by clicking on your starting and concluding points, letting the API plot what it deems to be the most direct route. Sounds cool, doesn’t it? In this tutorial I’ll show you how to implement this feature into your website, and perform other tasks such as determining the distance of the route, and even displaying route directions such as those available at http://maps.google.com/.

Snapping Points to a Route

The first thing we’ll need to figure out is how the API will plot a route along the known roads and other byways. This is accomplished using the loadFromWaypoints() method, which will accept an array of up to 25 coordinates (or alternatively addresses, and even a mix of the two), and then work out the route which connects these points. The following function will add a marker to the map, and append the marker’s coordinates to an array named coordinates (defined in the typical initialize() function). If the coordinates array ever consists of more than one set of coordinates, the loadFromWaypoints() method is called, resulting in a route between the coordinates being drawn.

function plotRoute(overlay, latlng) {

// Create a new marker based on the coordinates

var marker = new GMarker(latlng);

// Instantiate the GDirections class

var directions = new GDirections(map);

// Add the new marker to the map

map.addOverlay(marker);

// Create the new array element

coordinates_array_element = latlng.lat() + “,” + latlng.lng();

// Add the new array element to the map

coordinates.push(coordinates_array_element);

// If > one point on the map, plot the route between these two points

if (coordinates.length > 1) {

directions.loadFromWaypoints(coordinates);

}

}

As was demonstrated in the previous article, to execute a function when the user clicks on a map, just attach a listener to the map, as is shown below. I’ve placed this call in the initialize() function. If you don’t know what purpose the initialize() function serves, be sure to consult earlier articles in this series.

GEvent.addListener(map, “click”, plotRoute);

Avoiding Highways

The route plotted between Columbus and Cleveland logically guided the user along one of the state’s major highways, namely I-71. But what if you were planning a marathon bicycle ride between Columbus and Cleveland? You can tell the API to avoid using highways by modifying the loadFromWaypoints() method call like so:

directions.loadFromWaypoints(coordinates, {“avoidHighways”: true});

Once in place, reload the map and again plot the points between Columbus and Cleveland. You’ll notice the outbound route from Columbus avoids using I-71, as shown in Figure 2.

Figure 2. Avoiding highways along the route
Figure 2. Avoiding highways along the route

You can pass along other properties as well, including one (locale)for changing the map locale, and another (preserveViewport) which will zoom the map to an appropriate level in order to ensure the entire route appears within the map viewport. Consult the API documentation for a complete list of available properties.

Calculating the Route Distance and Trip Duration

You can also easily determine the distance and estimated travel time using the GDirection class’ getDistance() and getDuration()methods, respectively. However, because these values are not returned until the loadFromWaypoints() method returns the route, you’ll need to use a listener to retrieve the values at the appropriate time. For instance, the following listener waits for the directions object to load. Once loaded, the duration is retrieved, converted into minutes, and updated within a div named duration placed somewhere within the web page.

GEvent.addListener(directions, “load”, function() {

var duration = (directions.getDuration().seconds / 60).toFixed(2);

document.getElementById(“duration”).innerHTML = duration +

” minutes to arrive at your destination.”;

});

Figure 3. Displaying the estimated travel time
Figure 3. Displaying the estimated travel time

Displaying Route Directions

Sometimes you might wish to provide the user with directions from one point to the next. Adding this feature is shockingly easy; just modify your call to the GDirections object to identify the div where the directions should be inserted, like so:

var directions = new GDirections(map, document.getElementById(“sidebar”));

After adding the sidebar div to your web page, you’ll be able to create interfaces such as that shown in Figure 4.

Figure 3. Displaying the estimated travel time
Figure 3. Displaying the estimated travel time

Conclusion

This and the previous article present you with two easy ways to determine distance between multiple points on a map, whether its as the crow flies or as somebody might travel along an established roadway. If you wind up doing anything interesting with these features, I’d love to hear about it!

Configuring Apache2.2 mod_proxy_ajp with Tomcat

mod_proxy_ajp is an Apache module which can be used to forward a client HTTP request to an internal Tomcat application server using the AJP protocol.  In this example I have used JSPWki as the example application running on a Windows server with Apache2.2 and Tomcat 5.5

Advantages of mod_proxy_ajp rather:

  • You can gain a lot of flexibility (lot of the apache modules/features can be used especially “name-based virtual hosting”)
  • Practical for those who need to support Java applications along with PHP / Perl … (only one apache server is needed)
  • Certificates management is easier in apache configuration (this argument is a lot subjective)
  • It’s not Tomcat’s main objective to serve http static resources (not optimized for that)
  • Load balancing/cluster management is easier with an apache frontend

Tomcat configuration

We just have to create the AJP connector in the conf/server.xml file like that:

<Connector port="8009" enableLookups="false" redirectPort="8443" protocol="AJP/1.3" />

This line will enable AJP connections to the 8009 port of your tomcat server (localhost for example).

Apache2 configuration

One way (useful if this apache is a global front end) is to create a virtual host for this application.

  • ProxyPass and ProxyPassReverse are classic reverse proxy directives used to forward the stream to another location.
  • ajp://… is the AJP connector location (your tomcat’s server host/port)

# JSP Wiki DNS

<VirtualHost 10.1.1.170:80>

ServerName wiki.example.com

ServerAlias wiki

DocumentRoot “D:/Tomcat 5.5/webapps/JSPWiki/”

#DocumentRoot “D:/Apache2.2/htdocs/JSPWiki”

<Proxy *>

AddDefaultCharset Off

Order deny,allow

Allow from all

</Proxy>

ProxyPass / ajp://localhost:8009/

ProxyPassReverse / ajp://localhost:8009/

</VirtualHost>

The following entries were made in server.xml on the Tomcat App Server :

<Host name=”wiki.example.com” debug=”0″

appBase=”D:/Tomcat 5.5/webapps”

unpackWARs=”true” autoDeploy=”true”>

<Alias>wiki</Alias>

<Context path= “” docBase=”D:/Tomcat 5.5/webapps/JSPWiki” debug=”1″/>

<Valve className=”org.apache.catalina.valves.AccessLogValve”

directory=”logs” prefix=”home_access_log.” suffix=”.txt”

pattern=”common” resolveHosts=”false”/>

</Host>

Under JSPWiki/WEB-INF/jspwiki.properties the Base URL was modified as follows :

jspwiki.baseURL=http://wiki/JSPWiki/

Why Lower case table names are not possible in windows for MySql

lower_case_table_names

If set to 1, table names are stored in lowercase on disk and table name comparisons are not case sensitive. If set to 2 table names are stored as given but compared in lowercase. This option also applies to database names and table aliases. See Section Identifier Case

If you are using InnoDB tables, you should set this variable to 1 on all platforms to force names to be converted to lowercase.

You should not set this variable to 0 if you are running MySQL on a system that does not have case-sensitive filenames (such as Windows or Mac OS X). If this variable is not set at startup and the filesystem on which the data directory is located does not have case-sensitive filenames, MySQL automatically sets lower_case_table_names to 2.