Overview

Almost every programmer has got to the point where he worked with more than one thread, and then started synchronizing them. Today’s applications become not only multi threaded but also distributed, that is, an application can run on different processors and even different computers. Synchronizing such application is a very difficult task, and that is where our new project comes handy.

We provide a one class Monitor object that provides distributed getLock, releaseLock as well as wait-notify functionality.

Configuration

Synchronizing

Use org.jdsf.dl.LockObject to perform distributed synchronization.

Please note that the lock can be created only on String objects at this time.

Wait-notify

Use org.jdsf.dl.LockObject to perform distributed wait-notify.

Please note that at the current version the wait and notify method do not lock/release the distributed monitor.

An example use of JDSF can be found in the current release under the examples folder.

Each String creates a lock only for the relevant String value, in this way multiple Distributed lock can be created.

After a very long time of infrastructure development I have taken some time to get myself familiar again with web development and web frameworks. I did not keep my search contained to the Java domain but I kept coming back to Java because I like java and because Java provided me with everything I needed.

Well almost anything….

Most people interact with applications via graphical user interface. Graphical user interface (such as web interface) exposes the functionality of the application; it should be easy to use, nice to look at, personalized and customized to meet all the end-user needs. This is a very hard task as is and should not be made more complex by cumbersome web frameworks. The main problem in J2EE was that developers must face 100 percent of Java EE’s complexity even if they only need 20 percent of the services.

To address these issues, several simpler frameworks, all intended to help developers, were created. One of the most promising and best known to date is Spring- a simple-to-use application framework that provides programmers with the same Java EE functionality they need, but with a fraction of the complexity and cumbersomeness. I have worked a little with Spring MVC web framework and I enjoyed developing with it.

But, at the risk of sounding greedy, this is not enough. It should be simpler and easier to develop a well-structured, MVC, web applications.

One way of doing so would be with the help of graphical tools (an eclipse plug-in…)

These tools should help developers:

I figured that for 16bytes.com I would do a new research on open source CMS. I used Drupal for my last site but was determined to keep an open mind.

After a quick search in Google I decided to install mambo / joomla. My first reaction was “WOW, these guys know how to do CMS”. The GUI was great and it looked like a feature-full CMS.

Well, I came to my senses after two days of tedious configuration, rigid and complex management and a few explorer crashes. Reading a few blogs made it all clear, Mambo / joomla have great marketing people but they are still wanting in many CMS aspects. And while Drupal has something to learn about marketing and professional UI (the default user-interface of Drupal should be as good as mambo / joomla and currently it is not), they certainly hit the spot when it comes to CMS.

There are some things that are still missing from Drupal but I can certainly say – Drupal rocks!

FacesIDE plugin comes in very handy when you need to develop JSF applications.

However, when put into work, there are two changes you need to make by hand to the web.xml file it creates in the project structure.

This blog shows how to tweak the plugin so you don’t need to make those changes manually every time you create a new JSF project.

1. Open your eclipse’s plugins directory (In my installation eclipse is installed directly under c:\ so the plugins directory is c:\eclipse\plugins).Find FacesIDE plugin’s directory – c:\eclipse\plugins\tk.eclipse.plugin.jsf_2.0.2\myfaces-1.1.3\conf (the version number might change depending on the version of the plugin you have installed).
2. Find web.xml and open it in an editor.
3. Towards the end of the file you will find the following section:

   <!-- virtual path mapping -->
   <!--
       <servlet-mapping>
           <servlet-name>Faces Servlet</servlet-name>
           <url-pattern>/faces/*</url-pattern>
   
       </servlet-mapping>
   -->
   

   The virtual path mapping allows for the JSF Servlet to grab all requests for JSF pages.

   Remove the comment surrounding the servlet-mapping tag and save the file. You will no longer have to do it manually for every JSF project you create.

4. There’s one more thing you can do in this file, so you won’t have to change the filter attribute manually for Tomcat.Find the section starting with :

       <!-- Extensions Filter -->
   

   In the filter-class tag, change the original content of org.apache.myfaces.component.html.util.ExtensionsFilter to read org.apache.myfaces.webapp.filter.ExtensionsFilter

   Don’t forget to save the file.

That’s it. The next JSF project you create using this plugin will have those two changes ready out-of-the-box for you, and save you some work.

Explanation:

The FacesIDE plugin creates a file structure for a JSF application inside your eclipse project. One of the files that the plugin creates is the web.xml file.

What you did just now changes the original web.xml file used by the plugin, and so, the next time the plugin is used, the altered version will be used.

I have several accounts in my msn messenger. Yesterday one of my accounts just wouldn’t sign-in.

My live messenger kept trying to sign-in forever, setting a false password returned an error message and I had no problem sign-in with my other msn account.
After spending two hours on this problem and in the spirit of 16bytes, I decided to post the solution to this problem.

I found two solutions on the web, one did not work, but maybe it will be helpful for others.
The solution that did not work for me:
“To correct this, click Start, then Run, then type:
%appdata%\microsoft
and click OK.
Right-click the MSN Messenger folder and choose Delete. After all this, restart Messenger
and see if the problem has been corrected.”

Here it is source of this solution

It toke me quite a while to find the other solution, it looked risky because it involved regedit, but it did the trick.
The solution that worked:
“1. Hit “run” in the start menu
2. Type “regedit”
3. Open “HKEY_CURRENT_USER\Software\Microsoft\MSNMessenger”
4. Delete the folder called MSN Messenger
5. After this MSN Messenger Live will login as normal.”
Here it is source of this solution

The second solution involves playing with the computer registry so be careful and “do not try this at home” if you do not know what your doing.

This blog shows you how to configure an entirely open-source JSF development and test platform.

Eclipse can be easily set up to support JSF development with FacesIDE and Tomcat. The process is quite easy – if you have the right plugins.
In Eclipse architecture, plugins are additions to the basic platform. Actually, when you install eclipse, many plugins are already there for you under the hood. They serve as extensions, builts on the basic functionality provided by the platform.
If you want the basic eclipse to serve as a JSF development workbench, a good choice would be to add the FacesIDE plugin to it.
FacesIDE is an open source eclipse plugin designed for JSF development. It contains some functions that allow you to easily make your eclipse project a JSF project and code away without having to focus on JSF’s tidbits.
What you need:

1. An eclipse installation.
   You may have some problems configuring the FacesIDE plugin on eclipse level lower than 3.2. I prefer using a Callisto distribution but a simple eclipse should suffice. You may download it from IBM’s site (internal links there tend to change a lot, so just go to IBM site and search for ‘callisto’, Select the Java EE project bundle).
2. Tomcat.
   I use Tomcat 5.5 but any other will do.
   You can download Tomcat from here and installation is quite straightforward
3. Additionally, you may use SysDEO’s Tomact plugin to ease deploying and testing your application. It is downloadable here. make sure that you download the version that supports your version of eclipse.
4. The FacesIDE plugin.
   These are actually two plugins that you need. Both are downloadable from here.You need both EclipseHTMLEditor and FacesIDE plugins.

You are now ready to set up your environment.

1. If you haven’t got eclipse installed already, extract the archive that you downloaded. You can extract it anywhere, but for this tutorial I assume that it is extracted into c:\.
2. Install Tomcat if you haven’t done it yet.
3. Eclipse’s file structure is simple. You have a directory called c:\eclipse. Under this directory you have a plugins directory. This directory holds all the plugins that you have installed. You will now add the three plugins there.
   Extract both EclipseHTMLEditor and FacesIDE archives to c:\eclipse. The archives contatin a \plugins directory, and therefore the contents will be extracted to c:\eclipse\plugins, where plugins should reside.
4. Install Sysdeo Tomcat plugin under eclipse.Unzip the plugin’s archive under c:\eclipse\plugins (this archive does not contain a \plugins directory, so you need to extract it there yourself).
5. Configure Eclipse
   If you already used this eclipse, you may have to restart it using –clean attribute on the command (right click the shortcut for eclipse, and select properties. Enter ‘-clean’ at the ‘Target’ textbox). Remember to remove the -clean attribute after you verify that the plugins are active.
6. Confirm that the plugins are installed : Before we can start, we must confirm that eclipse registered the three new plugins.
   1. In eclipse, go to the Help menu, and select ‘About Eclipse SDK’.
   2. A pop-up window opens. Click on the button labeled ‘Plug-in Details’. This should display a list of all the plugins installed.
   3. Scroll down to the bottom of the list. You should see the following:Click here for a full screen image.
      Make sure that the FacesIDE, FacesIDE Visual page designer, the HTML/JSP/XML Editor and the SYSDEO plugins are listed. (They are shown on the bottom of the list).
   4. If the plugins are not found there, close this list, and click the ‘Configuration Details’ button. Check the error log there to see what went wrong.
7. In eclipse’s main toolbar you should see Tomcat’s buttons and menu item. If they are not present, you will need to do the following:
   1. From eclipse main menu select Window->Customize Perspective->Commands.
   2. Check the box next to Tomcat in the commands tab and click OK.Click here for a full screen image.
8. Before you can use Tomcat from eclipse, you need to set Tomcat’s properties.
   1. In eclipse’s menu select Window->preferences.Under Tomcat, set the tomcat version you use and Tomcat’s home.

      Click here for a full screen image.
      In this example I am using Tomcat 5.5, so ‘version 5.x’ is selected. Tomcat home points to the containing directory of Tomcat’s installation.

   2. If you are using Tomcat version 5.5.12 and above, make sure that the context declaration mode is ‘Context files’.
   3. Inside the archive for Tomcat’s plugin there’s another archive named DevLoader.zip. extract this archive under %Tomcat’s home%\server\classes (On my computer this will be C:\Program Files\Apache Software Foundation\Tomcat 5.5\server\classes)
   4. The plugin points Tomcat to eclipse’s default JRE, however, this must be a JDK and not a JRE (Think: you need to be able to compile JSP’s). So, you must make sure that the default runtime for eclipse is indeed a JDK (Open Window->Preferences, and expand the Java node. Under there, check Installed JREs, to make sure that you are indeed using a JDK as the default one for eclipse).
      Check that the configuration is correct by starting Tomcat from eclipse toolbar. You should see the server starting in the console with no exceptions :Click here for a full screen image.

   Creating a Tomcat/JSF project
   The last part of this blog describes how to create a Tomcat-ready JSF project in the configuration you just completed. In the next blog I will show how to create a simple JSF application and deploy it to Tomcat from within eclipse.

   1. A project in eclipse is a container for your code, and it’s the first thing you need to create for your JSF application (or any application for that matter).
      1. In eclipse menu, select File->New->Project
      2. In the wizard you see, expand ‘Java’ and select ‘Tomcat Project’ underneath it. Click on Next.
      3. Enter a name for your project and click Next.
      4. In the next screen you see the ‘Context Name’ of your application. This is the place inside Tomcat that your application will be deployed. It defaults to the project name.
         Additionally you see a ‘Subdirectory to set as web application root’ text box. it defaults to ‘/’ – which means the top level of your project file-structure. I usually prefer to set it to ‘/webcontent’ and work from there. Click Finish.
   2. Eclipse creates a new project. It is Tomcat-ready, and you can see it in the Project Explorer view on the left of the eclipse window (workbench).Inside the project structure it has all the jars and definitions needed for Tomcat (you can see them in project properties, under Tomcat section). However, you now need to configure it for JSF development. (That is: tell eclipse that this is actually a JSF project and not an ordinary one).
      To achieve this, you need to create the file-structure for this project, and add JSF support. The plugins that you installed previously make this an easy task.
      1. The project contains a ‘webcontent’ folder inside (since we asked for this on project creation). Right click webcontent folder and create a new folder under it. This new folder will hold the JSF pages that you develop. Give this folder a meaningful name.
      2. Now we use the FacesIDE plugin to add JSF support to the project.
         Right click the project name in the Package Explorer, and select New->Other. In the wizard that you see, expand Amateras node and select ‘Add JSF Support’.Click Next.
         In the next wizard screen you need to supply the Web Application root. Notice that the wizard defaults to the name of your project, but this will not do.

         The Amateras plugin can not guess where your application root resides, so you need to manually enter it.
         Click the Browse button, and navigate to the root (webcontent folder). Select it and click on OK.

         Make sure that the three checkboxes are checked, and click Finish.
         Note: It is possible to create the web root of the application (webcontent in the example) directly under the project’s top directory. In my opinion, though, it is more manageable to divide the files in a certain directory structure.
         Moreover, keeping the structure this way, will ease deployment into Tomcat later on.

      3. Verify that the application web root is set.
         Right click your project, and select properties. In the screen that you see, select the Amateras node. See that the Root points to your web rootClick here for a full screen image.
      4. You need to manually change web.xml for Tomcat to use the correct listener class for the JSF project.
         Open web.xml file under webcontent/WEB-INF and find the listener section inside it.
         change the listener-class tag to point to org.apache.myfaces.webapp.filter.ExtensionsFilter.

   You now have a JSF-oriented eclipse project under your hand. In the next blog we will use all the setup done here to develop and deploy a JSF application to Tomcat.

How to turn off the user Account Control in Vista