“I can’t organize all the chapters that I download of every TV show and because of that I always lost some files and I need to be downloaded. Because of that I’ve tried to do an app that do this hard work instead of me.”

If you follow some TV Shows by the internet, sure you know that all the files of the shows (ripped by the main groups (eztv, LOL, or something like that)) have the same simple pattern:

TV Show Name.Season.Chapter.Quality.Extension

 

 

Following this pattern and this idea this app only do a analysis in the download folder where my prefered app downloads the shows. Once these files have been detected the app distribute them in some folders, one for each tv show so I can have all the chapters of a show in a same folder and separated by the others tv shows. With this thoughts born “Organize TV Shows Downloads”.

The application is developed in Pyhon and it only has one window with no many options, so you can choose the following options:

• Download folder: The folder where the chapters of your favourites tv shows are placed.
• Output folder: The root folder where the chapters must be placed with a folder for each tv show.
• Extensions used: You can specify the list of file extensions of the files that will been trasfered of the new location (you can include AVI Files, Subtitles files and all the stuff you need).

1. Suppose that you have a folder with this content:

1. After invoke the application I’m explained in this post, you will have this final structure:

The EJB artifacts are Java components that in the modern times (forget about the 2.1 version!!) support dependency injection. So, when the EJB container is in execution, it has the goal to instance the EJB and all its dependencies and give to us an “completed object” when all the dependencies set, but you don’t have any EJB container when you are running your JUnit test, so what you can do? Ok, there is a free software library which can help us with that. The name of the project is the following: Ejb3Unit, and you can get it by these URL: http://ejb3unit.sourceforge.net/.

This library supports dependency injection and provides testing capabilities with your session beans and entities. It’s very simple to use, here is an example of a session bean test in Junit:

public class DIFieldSessionBeanTest extends BaseSessionBeanFixture<MySessionBean> {

	private static final Class[] usedBeans = { };

	public DIFieldSessionBeanTest() {
		super(MySessionBean.class, usedBeans);
	}

	public void testDependencyInjection() {
		final MySessionBean toTest = this.getBeanToTest();
		assertNotNull(toTest);
		assertNotNull(toTest.getDs());
		assertNotNull(toTest.getEm());
	}

When your Session is coded with the name of MySessionBean, so you can see it’s very easy to use this library and very useful.

So, one tip. Please, do not provider a setup method (NOT @Before annotation) because in this case the injection fails and it’s not worker properly. If you want to do some preparations, use the public constructor of the test, not a @Before method.

You can use this technology to measure resources of your Java project, such as, number of threads alive, memory consumption and every thing you want to measure, and you can use the JConsole to get an interaction with the kind of resources.

The main part of this technology is the MBean. As we can see in the Java documentation:

A standard MBean is defined by writing a Java interface called SomethingMBean and a Java class called Something that implements that interface. Every method in the interface defines either an attribute or an operation in the MBean. By default every method defines an operation. Attributes and operations are simply methods which follow certain design patterns. A standard MBean is composed of the MBean interface which lists the methods for all exposed attributes and operations, and the class which implements this interface and provides the functionality of the instrumented resource.

 

So, you will use this kind of artifacts to define the attributes and the methods you can use to interact with the rest of your application. Now, we are going to define an example with the name HelloMBean:

public class Hello implements HelloMBean {
    public void sayHello() {
	System.out.println("hello, world");
    } 

    public int add(int x, int y) {
	return x + y;
    } 

    public String getName() {
	return this.name;
    } 

    public int getCacheSize() {
	return this.cacheSize;
    } 

    public synchronized void setCacheSize(int size) {
	this.cacheSize = size; 

	System.out.println("Cache size now " + this.cacheSize);
    } 

    private final String name = "Reginald";
    private int cacheSize = DEFAULT_CACHE_SIZE;
    private static final int DEFAULT_CACHE_SIZE = 200;
}

This is the interface of the MBean and now, you need to do a java implementation:

public interface HelloMBean { 

    public void sayHello();
    public int add(int x, int y); 

    public String getName(); 

    public int getCacheSize();
    public void setCacheSize(int size);
}

So we have now all the parts of the bean created, but we need to implement a JMX agent, so the JMX clients like JConsole cand stablish a connection to our application so it can be controlled by it. The code must be something like that:

import java.lang.management.*;
import javax.management.*; 

public class Main { 

   public static void main(String[] args) throws Exception { 

      MBeanServer mbs = ManagementFactory.getPlatformMBeanServer(); 

      ObjectName name = new ObjectName("com.example.mbeans:type=Hello"); 

      Hello mbean = new Hello(); 

      mbs.registerMBean(mbean, name); 

      System.out.println("Waiting forever...");
      Thread.sleep(Long.MAX_VALUE);
   }
}

When you do something like that, and you start this Main program, you can use a JConsole instance to do a connection with our implementation, like we can see in this screenshot:

As you can see, you can invoke the operation you defined as part of your interface. And you can refresh the values of the attributes defined in the implementation.

The main difference between JiBX and the other Java libraries is that JiBX modifies the class files generated by the javac compiler and it adds some bytecodes which contains some methods that are used when you do the convertions between class file and xml file.

The only thing you must do to use this is define a XML document where you specify the mapping between the class file and the XML file output.

And how these kind of libraries works integrated with you usual IDE? That’s a good question. First of all it has a eclipse plugin that allows to do this post-compilation phase in a easy ways for the developers, but it has some limitations.

The main distribution of a JiBX contains only one JAR File: jibx-run-<version>.jar that contains the classes to use the main features of the libraries. In addition to this library, the jibx distribution contains another JAR file which contains the clasess that are needed to do the post-compiilation file in the clasess you want to convert into XML files.

These are the two files that are included in the eclipse plugin but it exists another JAR file named jibx-extras-<version>.jar that allows you to include advanced features, but when you use some of the features you have a problem when you use the eclispe plugin because you will get an ClassNotDefFoundError because this jar is not included by default in the eclipse plugin. But you have a way to solve it.

Error: Unmarshaller class org.jibx.extras.HashMapperStringToComplex not found; on structure element at (line 5, col 164, in binding.xml)
Error running binding compiler
org.jibx.runtime.JiBXException: Binding binding.xml is unusable because of validation errors

You must include this JAR File in the build path of your project but not the “easy” way. This JAR must be included as an External JAR so its path must be an absolute path. We don’t know the reason of this little “hack” but it’s the only workaround to get it work!. It happends at least in version 1.2.3 of the JiBX Java Library.

If you are using maven you don’t have none of this problem, because Maven always use absolute paths of the local repository of JAR files.

References

[1] – JiBX Home Page - http://jibx.sourceforge.net/

[2] – JiBX Tutoria . http://jibx.sourceforge.net/tutorial/binding-start.html