journl do |post|

Spring Roo Entity Relationship Cheat Sheet

2012-01-22T23:31:00.000-08:00

One-to-Many on one side and Many-to-One on the other:

+------------------+
| Tables_in_tokens |
+------------------+
| token |
| ymcamember |
+------------------+

project --topLevelPackage com.my.tokens
persistence setup --provider HIBERNATE --database MYSQL --databaseName tokens --userName root
// persistence setup --provider HIBERNATE --database HYPERSONIC_IN_MEMORY

entity --class ~.domain.Token
entity --class ~.domain.YMCAMember

focus --class ~.domain.Token
field string --fieldName name --notNull --unique
field reference --fieldName ymcaMember --type ~.domain.YMCAMember

focus --class ~.domain.YMCAMember
field string --fieldName name --notNull --unique
field set --type ~.domain.Token --fieldName tokens --mappedBy ymcaMember --cardinality ONE_TO_MANY

controller all --package ~.web

Many-to-Many on both sides:
This represented using a third Junction Table.
Many-to-One from both tables into the new Junction Table which stores the unique-pairs.

+--------------------+
| Tables_in_meetups |
+--------------------+
| community |
| person |
| person_communities |
+--------------------+

This works correctly from a hibernate/jpa standpoint unfortunately the roo UI doesn't acknowledge that one side is the relation owner and so erroneously lets you control it from both sides while persisting from only one. In this case the Person's create page persists properly to the communities table.

project --topLevelPackage com.foo.meetups
persistence setup --provider HIBERNATE --database HYPERSONIC_IN_MEMORY

entity --class ~.domain.Community
entity --class ~.domain.Person

focus --class ~.domain.Community
field string name
field set --fieldName members --type ~.domain.Person --mappedBy communities --cardinality MANY_TO_MANY

focus --class ~.domain.Person
field string name
field set --fieldName communities --type ~.domain.Community --cardinality MANY_TO_MANY

controller all --package ~.web

One-to-One on both sides:

This is when each table has a reference to a single row in the other table.
Again the following works well from a JPA/Hibernate point of view but the ui select box needs to be tweaked to allow a nullable field if you need that since it defaults to non nullable for some reason, not a big deal.

+-----------------+
| Tables_in_shoes |
+-----------------+
| left_shoe |
| right_shoe |
+-----------------+
2 rows in set (0.00 sec)

mysql> describe left_shoe;
+---------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+---------+--------------+------+-----+---------+----------------+
| id | bigint(20) | NO | PRI | NULL | auto_increment |
| name | varchar(255) | NO | UNI | NULL | |
| version | int(11) | YES | | NULL | |
| partner | bigint(20) | YES | MUL | NULL | |
+---------+--------------+------+-----+---------+----------------+

project --topLevelPackage com.my.shoes
persistence setup --provider HIBERNATE --database MYSQL --databaseName shoes --userName root
entity --class ~.domain.LeftShoe
entity --class ~.domain.RightShoe
focus --class ~.domain.LeftShoe
field string --fieldName name --notNull --unique
field reference --fieldName partner --type ~.domain.RightShoe --cardinality ONE_TO_ONE
focus --class ~.domain.RightShoe
field string --fieldName name --notNull --unique
field reference --fieldName partner --type ~.domain.LeftShoe --cardinality ONE_TO_ONE
controller all --package ~.web

Creating an Amazon S3 Post Policy and uploading via Curl Http Post and ruby.

2011-05-17T15:10:00.000-07:00

This post shows you how to do the following:
1. create an amazon file upload policy document to allow uploads by users of audio files visible to the world.
2. using this policy document create a policy signature that can be used by web clients to http post/upload an mp3 file.
3. a demo command line client that will upload a sample file to your amazon s3 bucket.

K first off we're gonna assume you set up an amazon bucket, have an access_key and secret_access_key, pretty easy to do just head on over to the AWS management web console and set it up.
We'll also assume you have some file named test.mp3 you want to upload to s3.

In this demo I'll be using:
bucket=dreamlogs
sub_folder=folder # this is the subfolder where files will be uploaded.
AMAZON_ACCESS_KEY_ID=your_key
AMAZON_SECRET_ACCESS_KEY=you_secret_key
filename=test.mp3

Now we need to create an amazon s3 post policy that determines who has access to upload files to your bucket. There are many different kinds of policies with amazon web services so in this case you need something like the following:

This site got me started but seems to be pretty out of date, the doc links are dead:
http://s3.amazonaws.com/doc/s3-example-code/post/post_sample.html

Here's an example:

{
  "expiration": "repl_expiration",
  "conditions": [
    {"bucket": "repl_bucket" },
    {"acl": "repl_acl" },
    ["eq", "$key", "repl_foldername/repl_username/repl_filename"],
    ["content-length-range", 0, "repl_max_content_bytes"],
    ["starts-with", "$Content-Type", "repl_content_type"],
    {"redirect": "repl_s3url/repl_bucket/repl_foldername/repl_username/repl_filename"},
  ]
}

every variable starting with the word repl shoul be replaced with whatever permission you are trying to allow, here's what I put in my java .properties file.

BUCKET=bucketname
UPLOADDIR=somedir
CONTENT_TYPE=application/octet-stream
S3URL=http://s3.amazonaws.com
ACL=public-read
# example 20 megabytes would be 20 * 1048576 = 20971520 bytes
MAX_CONTENT_BYTES=20971520

Next up we need to remove carriage returns / line feeds then B64 encode this policy.
Finally sign it with our amazon secret key. The following is the main brain of my java web service its response is Json object with the policy and signature necessary for the client to then use to formulate a post file upload request to amazon s3.

    1 package my.aws.console.proj.web;
    2 
    3 import java.text.SimpleDateFormat;
    4 import java.util.Date;
    5 import java.util.TimeZone;
    6 
    7 import javax.management.timer.Timer;
    8 import javax.servlet.http.HttpServletRequest;
    9 
   10 import my.aws.console.proj.domain.PolicySignature;
   11 import my.aws.console.proj.tooling.PolicyGenerator;
   12 
   13 import org.apache.log4j.Logger;
   14 import org.springframework.roo.addon.web.mvc.controller.RooWebScaffold;
   15 import org.springframework.stereotype.Controller;
   16 import org.springframework.web.bind.annotation.RequestMapping;
   17 import org.springframework.web.bind.annotation.RequestMethod;
   18 import org.springframework.web.bind.annotation.RequestParam;
   19 import org.springframework.web.bind.annotation.ResponseBody;
   20 
   21 
   22 @RooWebScaffold(path = "policysignatures", formBackingObject = PolicySignature.class, update = false, delete = false, create = false)
   23 @RequestMapping("/policysignatures")
   24 @Controller
   25 public class PolicySignatureService {
   26     
   27     private static Logger logger = Logger.getLogger(PolicySignatureService.class);
   28     
   29     
   30     @RequestMapping(value = "/service", method = RequestMethod.GET, headers = "Accept=application/json")
   31     @ResponseBody
   32     public Object showJson(@RequestParam(value = "facebook_id", required = true) String facebook_id, 
   33                             @RequestParam(value = "filename", required = true) String filename, 
   34                             HttpServletRequest request) {
   35         PolicyGenerator generator = new PolicyGenerator();
   36         String formattedExpirationDate = getFormattedExpirationDate();      
   37         String generatedPolicy = makeAWSPostPolicy(facebook_id, filename, generator, formattedExpirationDate);
   38         String b64EncodedPolicy = generator.b64EncodePolicy(generatedPolicy);
   39         String signature = generator.signPolicy(generator.AWSSECRETKEY, b64EncodedPolicy);
   40         PolicySignature policysignature = makePolicySignature(facebook_id,
   41                 filename, generator, b64EncodedPolicy, signature);
   42         logger.info(request.getRemoteAddr()+","+ generatedPolicy +","+ policysignature.toJson());
   43         return policysignature.toJson();
   44     }
   45 
   46 
   47     public PolicySignature makePolicySignature(String facebook_id,
   48             String filename, PolicyGenerator generator, String b64EncodedPolicy,
   49             String signature) {
   50         PolicySignature policysignature = new PolicySignature();
   51         policysignature.setPolicy(b64EncodedPolicy);
   52         policysignature.setSignature(signature);
   53         policysignature.setAWSAccessKeyId(generator.AWSKEYID);
   54         policysignature.setBucket(generator.BUCKET);
   55         policysignature.setFkey(generator.UPLOADDIR+"/"+facebook_id+"/"+filename);
   56         policysignature.setContent_type(generator.CONTENT_TYPE);
   57         policysignature.setFile("@" + filename);
   58         policysignature.setS3url(generator.S3URL + "/" + generator.BUCKET);
   59         policysignature.setRedirect(generator.S3URL + "/" + generator.BUCKET + "/" + generator.UPLOADDIR + "/" + facebook_id + "/" + filename);
   60         policysignature.setAcl(generator.ACL);
   61         return policysignature;
   62     }
   63 
   64 
   65     public String makeAWSPostPolicy(String facebook_id, String filename,
   66             PolicyGenerator generator, String formattedExpirationDate) {
   67         String generatedPolicy = generator.generatePolicy(generator.AWSKEYID, generator.AWSSECRETKEY);      
   68         generatedPolicy = generatedPolicy.replaceAll("repl_expiration", formattedExpirationDate);
   69         generatedPolicy = generatedPolicy.replaceAll("repl_bucket", generator.BUCKET);
   70         generatedPolicy = generatedPolicy.replaceAll("repl_acl", generator.ACL);
   71         generatedPolicy = generatedPolicy.replaceAll("repl_filename", filename);
   72         generatedPolicy = generatedPolicy.replaceAll("repl_content_type", generator.CONTENT_TYPE);
   73         generatedPolicy = generatedPolicy.replaceAll("repl_max_content_bytes", generator.MAX_CONTENT_BYTES);
   74         generatedPolicy = generatedPolicy.replaceAll("repl_foldername", generator.UPLOADDIR);
   75         generatedPolicy = generatedPolicy.replaceAll("repl_username", facebook_id);
   76         generatedPolicy = generatedPolicy.replaceAll("repl_s3url", generator.S3URL);
   77         generatedPolicy = generatedPolicy.replaceAll("\r", "");
   78         generatedPolicy = generatedPolicy.replaceAll("\n", "");
   79         return generatedPolicy;
   80     }
   81 
   82 
   83     public String getFormattedExpirationDate() {
   84         Date now = new Date();
   85         Date oneHourFromNow = new Date(now.getTime() + Timer.ONE_HOUR);
   86         TimeZone tz = TimeZone.getTimeZone( "UTC" );
   87         SimpleDateFormat dfm = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
   88         dfm.setTimeZone( tz );
   89         String formattedExpirationDate = dfm.format(oneHourFromNow);
   90         return formattedExpirationDate;
   91     }    
   92 }
   93

The signing code and base 64 code was modeled after this security doc: http://docs.amazonwebservices.com/AWSSimpleQueueService/2007-05-01/SQSDeveloperGuide/SummaryOfAuthentication.html

package my.aws.console.proj.tooling;

import java.io.IOException;
import java.io.InputStream;
import java.security.SignatureException;
import java.util.Properties;



public class PolicyGenerator {

    public String BUCKET;
    public String DEFAULT_AMAZON_POLICY;
    public String AWSKEYID;
    public String UPLOADDIR;
    public String CONTENT_TYPE;
    public String S3URL;
    public String AWSSECRETKEY;
    public String ACL;
    public String MAX_CONTENT_BYTES;
    
    public PolicyGenerator() {
        InputStream policyInputStream = PolicyGenerator.class.getClassLoader().getResourceAsStream("permissive.json");
        InputStream bucketingInputStream = PolicyGenerator.class.getClassLoader().getResourceAsStream("amazon_bucketing.properties");
        InputStream credentialsInputStream = PolicyGenerator.class.getClassLoader().getResourceAsStream("AwsCredentials.properties");

        byte[] bytes = null;
        try {
            bytes = new byte[policyInputStream.available()];
            policyInputStream.read(bytes);
            DEFAULT_AMAZON_POLICY = new String(bytes);
            
            Properties awsprops = new Properties();
            awsprops.load(bucketingInputStream);
            BUCKET = awsprops.getProperty("BUCKET");
            UPLOADDIR = awsprops.getProperty("UPLOADDIR");
            CONTENT_TYPE = awsprops.getProperty("CONTENT_TYPE");
            S3URL = awsprops.getProperty("S3URL");
            ACL = awsprops.getProperty("ACL");
            MAX_CONTENT_BYTES = awsprops.getProperty("MAX_CONTENT_BYTES");
            
            Properties awscreds = new Properties();
            awscreds.load(credentialsInputStream);
            AWSKEYID = awscreds.getProperty("accessKey");
            AWSSECRETKEY = awscreds.getProperty("secretKey");

            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public String generatePolicy(String awsid, String awskey) {
        return DEFAULT_AMAZON_POLICY;
    }
    
    public String signPolicy(String awskey, String policy){
        try {
            return  Signature.calculateRFC2104HMAC(policy, awskey);
        } catch (SignatureException e) {
            e.printStackTrace();
        }
        return "error_signing_policy";
    }

    
    public String b64EncodePolicy(String policy){
        //policy = policy.replaceAll("\n", ""); #this breaks it for some unknown reason
        policy = policy.replaceAll("\r", "");
        return Encoding.EncodeBase64(policy.getBytes());
    }
    
    
    public String readJsonFile(String policyFile) {
        InputStream inputStream = PolicyGenerator.class.getClassLoader()
                .getResourceAsStream(policyFile);
        byte[] bytes = null;
        try {
            bytes = new byte[inputStream.available()];
            inputStream.read(bytes);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new String(bytes);
    }
    
}

As a test HTTP client we'll be using curl driven by ruby, its a pretty simple script you just have to set all the right curl flags and also worry about the order as amazon services are picky about that.

# this test will hit a server and then using the response upload a file to s3.
#
require 'json'
server = "http://192.168.254.6"
port = "8080"
facebook_user = "malcruzito"
filename= "test.mp3" #assumes this file exists in the directory you run the script from

#hit the server to get the permissions to upload
resp = `curl -H Accept:application/json "#{server}:#{port}/proj/policysignatures/service?facebook_id=#{facebook_user}&filename=#{filename}"`

parsed = JSON.parse(resp)

#puts parsed

#upload the file
curl_command = "curl -L -v -b cookiejar.txt -c cookiejar.txt "
curl_command += " -F \"policy=#{parsed['policy']}\""
curl_command += " -F \"acl=#{parsed['acl']}\""
curl_command += " -F \"redirect=#{parsed['redirect']}\""
curl_command += " -F \"signature=#{parsed['signature']}\""
curl_command += " -F \"AWSAccessKeyId=#{parsed['AWSAccessKeyId']}\""
curl_command += " -F \"bucket=#{parsed['bucket']}\""
curl_command += " -F \"key=#{parsed['fkey']}\""
curl_command += " -F \"content-type=#{parsed['content_type']}\""
curl_command += " -F \"file=#{parsed['file']}\""
curl_command += " #{parsed['s3url']}"

print curl_command +"\n"
result = `#{curl_command}`
p result

script to spin up an amazon ec2 instance and deploy a tomcat war

2011-04-29T12:06:00.000-07:00

It requires ec2-api-tools ssh scp curl and optionally xml2 to be installed somewhere on your machine.

This one is a real gem:

    1 export EC2_HOME=/location/of/ec2-api-tools-1.3-42584
    2 export PATH=$PATH:$EC2_HOME/bin 
    3 export EC2_PRIVATE_KEY=~/.ec2/secretkeyhere.pem 
    4 export EC2_CERT=~/.ec2/certhere.pem 
    5 export JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Home
    6 
    7 export curlflags="-L -v -b cookiejar.txt -c cookiejar.txt"
    8 export appname=war_you_want_deployed_without_extension
    9 
   10 my_instance=`ec2-run-instances ami-1515f67c -k gsg-keypair | grep INSTANCE | awk '{print $2}'`
   11 echo $my_instance 
   12 
   13 remotehost=`ec2-describe-instances $my_instance | grep INSTANCE | awk '{print $4}'`
   14 echo $remotehost 
   15 
   16 while [ "$remotehost" == "pending" ]
   17 do
   18     remotehost=`ec2-describe-instances $my_instance | grep INSTANCE | awk '{print $4}'`
   19     echo $remotehost    
   20 done
   21 
   22 
   23 ec2-authorize default -p 22
   24 ec2-authorize default -p 80
   25 ec2-authorize default -p 1194 -P udp
   26 ec2-authorize default -p 1194 -P tcp
   27 ec2-authorize default -p 8080
   28 ssh -i ~/.ssh/id_rsa-gsg-keypair ubuntu@$remotehost -o StrictHostKeyChecking=no 'sudo apt-get update -y'
   29 ssh -i ~/.ssh/id_rsa-gsg-keypair ubuntu@$remotehost 'sudo apt-get install openjdk-6-jdk -y'
   30 ssh -i ~/.ssh/id_rsa-gsg-keypair ubuntu@$remotehost 'java -version'
   31 ssh -i ~/.ssh/id_rsa-gsg-keypair ubuntu@$remotehost 'wget http://apache.mirror.nexicom.net/tomcat/tomcat-6/v6.0.32/bin/apache-tomcat-6.0.32.tar.gz'
   32 ssh -i ~/.ssh/id_rsa-gsg-keypair ubuntu@$remotehost 'tar -zxvf apache-tomcat-6.0.32.tar.gz'
   33 ssh -i ~/.ssh/id_rsa-gsg-keypair ubuntu@$remotehost 'apache-tomcat-6.0.32/bin/startup.sh'
   34 
   35 echo "my_instance=$my_instance"
   36 echo "remotehost=$remotehost"
   37 
   38 echo "curl $curlflags http://$remotehost:8080 | html2"
   39 curl $curlflags http://$remotehost:8080 | html2
   40 
   41 scp -i ~/.ssh/id_rsa-gsg-keypair $appname.war ubuntu@$remotehost:apache-tomcat-6.0.32/webapps/
   42 
   43 echo "curl $curlflags http://$remotehost:8080/$appname | html2"
   44 curl $curlflags http://$remotehost:8080/$appname | html2
   45 
   46 
   47 echo "my_instance=$my_instance"
   48 echo "remotehost=$remotehost"
   49 echo "server should be up at: http://$remotehost:8080/$appname"
   50 
   51 
   52 # 
   53 echo 'dont forget to shut it down when youre done it costs money!'
   54 echo "ec2-terminate-instances ${my_instance}"
   55

curl + 2xml for simple http get post web test command line scripting

2011-04-11T15:21:00.000-07:00

Web programming can get complicated pretty quickly. Everybody wishes they could automatically test their website when they make a change to ensure they haven't broken anything. For many websites this is a large and tedious task that screams out for automation. It would be nice if you could separate your web-application's functionality from the details of browser compatibility. Great strides have been taken to improve compatibility between browser versions but quirks still (and will probably always) exist.
Some web automation tests really can and should be agnostic of the web browser being used at that point in time. Whichever version of Firefox, Chrome, Safari, Opera, IE , Lynx :), etc.. people are into at that moment.

So to ensure your test automation doesn't rely on some test framework version or browser quirks, you must take the long view, you have to ensure you use only methods from the w3c http spec, get && post with or without cookies. These are the web operations most likely to not change and remain compatible for the lifetime of your application.

Two interesting ways of doing this are either via some curl library in your favorite programming language or alternatively via the handy curl executable compiled for your operating system, which is available on 99.99% of computers today.

Let me get this out of the way. "You obviously cannot execute or test all client side JavaScript via curl." Nevertheless when any regular Javascript or even Ajax function communicates with the server it does so using standard http commands and curl can handle all of those operations. Here are some very useful sample commands that might surprise you by their simplicity and power. A consequence of building your website to be testable in this manner enforces a restful and simple design, regardless of whether you continue to test this way in future. Most higher level web testing frameworks are compatible with the operations I'm going to show you in curl, so once you've spiked out your test at the command line you'll see its trivial to convert this into another language/framework since these basic operations are universal to the web itself.

If you add xml2 and the grep command you can easily prototype some test scenarios that could subsequently be scripted. The reason I'm doing this is that I often want to prototype new website designs and functions and I don't really want to have to manually log in and navigate to the page in question if this can be automated at the command-line.

If you followed along with my previous post on federated login with spring-roo you'll have a copy of the same app I'm running my commands against.
We'll assume you did and your server and app are:

myserver=http://localhost:8080
appname=openidlogin

Example:
Most pages need redirection capability so this means add the -L flag to follow the location as it changes.
Additionally we're gonna need to know where we've been redirected to, we'll also add the -v for verbose flag.

myflags="-L -v"

curl $myflags "$myserver/$appname/"

\\lots of html in here returned\\

So that's a lot of xhtml that came back lets make that human friendly with xml2/html2 and grep
xml2/html2 gives you an xpath representation of each xml element on a separate line which makes them grepable.

So for example:

curl $myflags "$myserver/$appname" | xml2

on my app i get back something like this:

/html/body/div/div/a/@title=Home
/html/body/div/div/a/@href=/openidlogin/;jsessionid=F5E83F4ABC01CB1B0C8D222E6AE22B29
/html/body/div/div/ul/li/ul/li/a/@title=Create new Employee
/html/body/div/div/ul/li/ul/li/a/@href=/openidlogin/employees;jsessionid=F5E83F4ABC01CB1B0C8D222E6AE22B29?form
/html/body/div/div/ul/li/ul/li/a/@title=List all Employees
/html/body/div/div/ul/li/ul/li/a/@href=/openidlogin/employees;jsessionid=F5E83F4ABC01CB1B0C8D222E6AE22B29?page=1&size=10
/html/body/div/div/ul/li/ul/li/a/@title=Find by Open Id Identifier
/html/body/div/div/ul/li/ul/li/a/@href=/openidlogin/employees;jsessionid=F5E83F4ABC01CB1B0C8D222E6AE22B29?find=ByOpenIdIdentifier&form
/html/body/div/div/div/div/@id=_title_title_id

This is not too bad actually. Right? And you were worried about not needing a web browser :). So you see here some link titles and hrefs for the basic CRUD operations on my app as well as a spring roo finder.
We also received a
Set-Cookie: JSESSIONID=F5E83F4ABC01CB1B0C8D222E6AE22B29; Path=/openidlogin
command from the server. This is our unique session token, it's been appended to our urls. Yours would be different.

To move forward from here, as is the case for many situations in life, we are going to need some cookies! Else every time we hit our server its going to think we are a different person. Curl gives us this functionality with two flags, one to store cookies, the other to send cookies. We store with a cookiejar -c flag. And we send with the -b flag. lets add those flags now.

myflags="-L -v -b cookiejar.txt -c cookiejar.txt"

Now if hit the site we only get a cookie the first time and it gets saved and sent along when necessary.

curl $myflags "$myserver/$appname/" | xml2

cat cookiejar.txt
beastinator.local FALSE /openidlogin FALSE 0 JSESSIONID 89CF82D8C4211D5C6913B9B911B67C2B

That's our session. simple. And since we stored our cookies properly the jsessionid isn't appended to the url anymore which cleans things up a lot:

/html/body/div/div/ul/@id=_menu
/html/body/div/div/ul/li/@id=c_employee
/html/body/div/div/ul/li/h2=Employee
/html/body/div/div/ul/li/ul/li/@id=i_employee_new
/html/body/div/div/ul/li/ul/li/a/@title=Create new Employee
/html/body/div/div/ul/li/ul/li/a/@href=/openidlogin/employees?form
/html/body/div/div/ul/li/ul/li/a=Create new Employee
/html/body/div/div/ul/li/ul/li
/html/body/div/div/ul/li/ul/li/@id=i_employee_list
/html/body/div/div/ul/li/ul/li/a/@title=List all Employees
/html/body/div/div/ul/li/ul/li/a/@href=/openidlogin/employees?page=1&size=10
/html/body/div/div/ul/li/ul/li/a=List all Employees
/html/body/div/div/ul/li/ul/li
/html/body/div/div/ul/li/ul/li/@id=fi_employee_openididentifier
/html/body/div/div/ul/li/ul/li/a/@title=Find by Open Id Identifier
/html/body/div/div/ul/li/ul/li/a/@href=/openidlogin/employees?find=ByOpenIdIdentifier&form
/html/body/div/div/ul/li/ul/li/a=Find by Open Id Identifier

Now lets try to go from here to the List operation on my Employee entity. namely the following link.

curl $myflags "$myserver/$appname/employees" | xml2

So here, based on the security settings for this app, we get redirected to a login page. As you can see in the header:

< HTTP/1.1 302 Moved Temporarily
< Server: Apache-Coyote/1.1
< Location: http://localhost:8080/openidlogin/login

Now things get interesting. We have three options to log in.

1. User/pass combo. In this case I've pre set up user1/password.
2. Sign in with Google Federated Login. So we'll have to sign in via a prelinked google openid.
3. Sign in with a more standard, Non-google openid provider. In this case I'll show you how to use myopenid.com.

1. User/pass combo method using user1/password. Lets look the first form action.

curl $myflags "$myserver/$appname/login" | xml2 | grep -i form

/html/body/div/div/div/div/form/@method=POST
/html/body/div/div/div/div/form/@action=/openidlogin/resources/j_spring_security_check
/html/body/div/div/div/div/form/@name=f
/html/body/div/div/div/div/form/div/label/@for=j_username
/html/body/div/div/div/div/form/div/label=Name
/html/body/div/div/div/div/form/div/input/@style=width:150px
/html/body/div/div/div/div/form/div/input/@name=j_username
/html/body/div/div/div/div/form/div/input/@type=text
/html/body/div/div/div/div/form/div/input/@id=j_username
/html/body/div/div/div/div/form/div/script/@type=text/javascript
/html/body/div/div/div/div/form/div/script=
/html/body/div/div/div/div/form/div/script= Spring.addDecoration(new Spring.ElementDecoration({elementId : "j_username", widgetType : "dijit.form.ValidationTextBox", widgetAttrs : {promptMessage: "Enter your name", required : true}}));
/html/body/div/div/div/div/form/div/script=
/html/body/div/div/div/div/form/br
/html/body/div/div/div/div/form/div/label/@for=j_password
/html/body/div/div/div/div/form/div/label=Password
/html/body/div/div/div/div/form/div/input/@style=width:150px
/html/body/div/div/div/div/form/div/input/@name=j_password
/html/body/div/div/div/div/form/div/input/@type=password
/html/body/div/div/div/div/form/div/input/@id=j_password
/html/body/div/div/div/div/form/div/script/@type=text/javascript
/html/body/div/div/div/div/form/div/script=
/html/body/div/div/div/div/form/div/script= Spring.addDecoration(new Spring.ElementDecoration({elementId : "j_password", widgetType : "dijit.form.ValidationTextBox", widgetAttrs : {promptMessage: "Enter your password", required : true}}));
/html/body/div/div/div/div/form/div/script=
/html/body/div/div/div/div/form/br
/html/body/div/div/div/div/form/div/@class=submit
/html/body/div/div/div/div/form/div/script/@type=text/javascript
/html/body/div/div/div/div/form/div/script=Spring.addDecoration(new Spring.ValidateAllDecoration({elementId:'proceed', event:'onclick'}));
/html/body/div/div/div/div/form/div/input/@value=Submit
/html/body/div/div/div/div/form/div/input/@type=submit
/html/body/div/div/div/div/form/div/input/@id=proceed
/html/body/div/div/div/div/form/div/input
/html/body/div/div/div/div/form/div/input/@value=Reset
/html/body/div/div/div/div/form/div/input/@type=reset
/html/body/div/div/div/div/form/div/input/@id=reset

Pretty simple. We have j_username and j_password fields with submit and reset buttons and the http method is post to this url /openidlogin/resources/j_spring_security_check.

So in curl to make a post command all we have to do is add the data flag -d and point to the action url, like the following.

curl $myflags -d "j_username=user1&j_password=password" "$myserver/$appname/resources/j_spring_security_check" | xml2

thats it! we're in. we don't have to send the username and password again so we don't need to add this to $myflags since our session cookie keeps us authenticated.

lets log out now and try the next method.
curl $myflags "$myserver/$appname/resources/j_spring_security_logout" | html2

2. lets try it for google. this is the part of the form we're interested in:
visit google sign in page to get the GALX cookie
curl $myflags http://gmail.com

grab the GALX token from the cookie:
GALX=`cat cookiejar.txt | grep www.google.com | grep GALX | awk '{print $NF}'`

set a google user and pass
goog_user=your_goog_email
goog_pass=your_goog_pass

login to google:
curl $myflags -d "Email=$goog_user&GALX=$GALX&Passwd=$goog_pass&asts=&continue=https://mail.google.com/mail/?&dnConn=&dsh=$dsh&hl=en<mpl=default<mplcache=2&pstMsg=&rm=false&rmShown=1&scc=1&secTok&service=mail&signIn=Sign in&ss=1&timeStmp=" https://www.google.com/accounts/ServiceLoginAuth | html2

you now have all the fancy google cookies you need for oauth. (also google is tracking you :) )

So here's how we use the fancy cookies to log into our site. I'm going to assume you already granted permissions on the google account in question for this app.

so lets look at the part of our form that does google oauth:

curl $myflags "$myserver/$appname/login" | html2 | grep -i form

/html/body/div/div/div/div/form/@method=post
/html/body/div/div/div/div/form/@action=/openidlogin/j_spring_openid_security_check;jsessionid=00FD152C5918A248CD10CEC030C4F864
/html/body/div/div/div/div/form/input/@value=http://www.google.com/accounts/o8/id
/html/body/div/div/div/div/form/input/@type=hidden
/html/body/div/div/div/div/form/input/@maxlength=100
/html/body/div/div/div/div/form/input/@size=50
/html/body/div/div/div/div/form/input/@name=openid_identifier
/html/body/div/div/div/div/form/div/@class=submit
/html/body/div/div/div/div/form/div/input/@value=Sign in with Google
/html/body/div/div/div/div/form/div/input/@type=submit
/html/body/div/div/div/div/form/div/input/@id=proceed_google

looks like all we need to do is send on the hard coded openid_identifier http://www.google.com/accounts/o8/id

curl $myflags -d "openid_identifier=http://www.google.com/accounts/o8/id" "$myserver/$appname/j_spring_openid_security_check"

let all the fancy oauth redirecting do its thing with your cookies, then you can query employees since you are logged in!

curl $myflags "$myserver/$appname/employees" | html2 | grep "/html/body/div/div/div/div/table/tr/td="

/html/body/div/div/div/div/table/tr/td=ACTIVE
/html/body/div/div/div/div/table/tr/td=ROLE_ADMIN
/html/body/div/div/div/div/table/tr/td=5e884898da
/html/body/div/div/div/div/table/tr/td=user1
/html/body/div/div/div/div/table/tr/td=ACTIVE
/html/body/div/div/div/div/table/tr/td=ROLE_USER
/html/body/div/div/div/div/table/tr/td=5e884898da
/html/body/div/div/div/div/table/tr/td=user2
/html/body/div/div/div/div/table/tr/td=Peter
/html/body/div/div/div/div/table/tr/td=RESIGNED
/html/body/div/div/div/div/table/tr/td=ROLE_USER
/html/body/div/div/div/div/table/tr/td=5e884898da
/html/body/div/div/div/div/table/tr/td=user3
/html/body/div/div/div/div/table/tr/td=Christina
/html/body/div/div/div/div/table/tr/td=

lets log out now and try the next method.
curl $myflags "$myserver/$appname/resources/j_spring_security_logout" | html2

3. Sign in with a more standard, Non-google openid provider. In this case I'll show you how to use myopenid.com.
head back to the login page and examine the third form action.

curl $myflags "$myserver/$appname/login" | xml2 | grep -i form

/html/body/div/div/div/div/form/@action=/openidlogin/j_spring_openid_security_check
/html/body/div/div/div/div/form/div/label/@for=openid_identifier
/html/body/div/div/div/div/form/div/label=OpenID
/html/body/div/div/div/div/form/div/input/@style=width:150px
/html/body/div/div/div/div/form/div/input/@type=text
/html/body/div/div/div/div/form/div/input/@name=openid_identifier
/html/body/div/div/div/div/form/div/input/@id=openid_identifier
/html/body/div/div/div/div/form/br
/html/body/div/div/div/div/form/div/@class=submit
/html/body/div/div/div/div/form/div/input/@value=Submit
/html/body/div/div/div/div/form/div/input/@type=submit
/html/body/div/div/div/div/form/div/input/@id=proceed_openid

so as before once we have our openid provider's cookie, we just send our openid provider url as a form post parameter and direct curl to the j_spring_openid_security_check action .

example for myopenid.com:

curl $myflags -d "openid_identifier=https://thamster.myopenid.com" "$myserver/$appname/j_spring_openid_security_check" | html2

so to sign in to myopenid.com you do the following:
curl $myflags "https://www.myopenid.com/signin" > myopenidsignin.html
blank=`cat myopenidsignin.html | html2 | grep "=_$" -A 1 | grep value | awk -F"@value=" '{print $2}' | tail -n 1`
tid=`cat myopenidsignin.html | html2 | grep "=tid$" -A 1 | grep value | awk -F"@value=" '{print $2}' | tail -n 1`
token=`cat myopenidsignin.html | html2 | grep "=token$" -A 1 | grep value | awk -F"@value=" '{print $2}' | head -n 1`
myopen_user=your_username
myopen_pass=your_password

curl $myflags -d "user_name=$myopen_user&password=$myopen_pass&_=$blank&tid=$tid&token=$token" "https://www.myopenid.com/signin_submit"

curl $myflags -d "openid_identifier=https://$myopen_user.myopenid.com" "$myserver/$appname/j_spring_openid_security_check" | html2

Thats it you're in. congrats, you didn't even need a browser.

    1 ## summary
    2 ## for those of you who read bash better than english. 
    3 
    4 myflags="-L -v -b cookiejar.txt -c cookiejar.txt"
    5 myserver=http://localhost:8080
    6 appname=openidlogin
    7 
    8 #login with username and pass
    9 curl $myflags -d "j_username=user1" -d "j_password=password" "$myserver/$appname/resources/j_spring_security_check" | html2
   10 
   11 #login with google oauth
   12 #simplified gmail oauth login
   13 curl $myflags http://gmail.com
   14 GALX=`cat cookiejar.txt | grep www.google.com | grep GALX | awk '{print $NF}'`
   15 goog_user=your_goog_user
   16 goog_pass=your_goog_pass
   17 curl $myflags -d "Email=$goog_user&GALX=$GALX&Passwd=$goog_pass&asts=&continue=https://mail.google.com/mail/?&dnConn=&dsh=$dsh&hl=en&ltmpl=default&ltmplcache=2&pstMsg=&rm=false&rmShown=1&scc=1&secTok&service=mail&signIn=Sign in&ss=1&timeStmp=" https://www.google.com/accounts/ServiceLoginAuth | html2
   18 curl $myflags -d "openid_identifier=http://www.google.com/accounts/o8/id" "$myserver/$appname/j_spring_openid_security_check"
   19 
   20 
   21 #login with myopenid.com
   22 curl $myflags "https://www.myopenid.com/signin" > myopenidsignin.html
   23 blank=`cat myopenidsignin.html | html2 | grep "=_$" -A 1 | grep value | awk -F"@value=" '{print $2}' | tail -n 1`
   24 tid=`cat myopenidsignin.html | html2 | grep "=tid$" -A 1 | grep value | awk -F"@value=" '{print $2}' | tail -n 1`
   25 token=`cat myopenidsignin.html | html2 | grep "=token$" -A 1 | grep value | awk -F"@value=" '{print $2}' | head -n 1`
   26 myopen_user=username
   27 myopen_pass=password
   28 curl $myflags -d "user_name=$myopen_user&password=$myopen_pass&_=$blank&tid=$tid&token=$token" "https://www.myopenid.com/signin_submit"
   29 curl $myflags -d "openid_identifier=https://$myopen_user.myopenid.com" "$myserver/$appname/j_spring_openid_security_check" | html2
   30 
   31 #logout 
   32 curl $myflags "$myserver/$appname/resources/j_spring_security_logout" | html2
   33 
   34 #list employees once logged in
   35 curl $myflags "$myserver/$appname/employees" | html2 | grep "/html/body/div/div/div/div/table/tr/td="
   36 
   37

more info on curl can be found here:
http://curl.haxx.se/docs/manual.html
http://curl.haxx.se/docs/manpage.html

myopenid + google federated login + with spring roo. dead simply.

2011-04-11T14:44:00.000-07:00

##gonna clean up the formatting on this article soon.
## this step by step guide is based on the following excellent article:
http://bsgdev.wordpress.com/2011/01/18/exploring-google-and-openid-login-with-spring-security-and-spring-roo/

# Project
project --topLevelPackage za.co.bsg.rnd.trf.openidlogin

# Persistence
persistence setup --provider HIBERNATE --database HYPERSONIC_IN_MEMORY --databaseName openidlogin --hostName localhost

# Dependencies
dependency add --groupId org.springframework.security --artifactId spring-security-openid --version 3.0.5.RELEASE
dependency add --groupId org.openid4java --artifactId openid4java --version 0.9.5

# Domain model
enum type --class ~.domain.UserRole
enum constant --name ROLE_ADMIN
enum constant --name ROLE_USER

enum type --class ~.domain.EmployeeStatus
enum constant --name ACTIVE
enum constant --name DORMANT
enum constant --name RESIGNED
enum constant --name TERMINATED

entity --class ~.domain.Employee --table employee --identifierColumn employee_id
field string --fieldName username --column username --notNull
field string --fieldName password --column password --notNull
field enum --type ~.domain.UserRole --fieldName userRole --notNull --enumType STRING
field string --fieldName openIdIdentifier --column openid_identifier
field string --fieldName firstName --column first_name
field string --fieldName lastName --column last_name
field string --fieldName emailAddress --column email_address
field enum --type ~.domain.EmployeeStatus --fieldName status --notNull --enumType STRING

# we will also need a finder
finder add --finderName findEmployeesByOpenIdIdentifier --class ~.domain.Employee

# Scaffold the web frontend
controller all --package ~.web

# Spring Security
security setup

# Other classes
class --class ~.InsertTestData
class --class ~.OpenIdUserDetailsService

Now implement these two java classes InsertTestData.java simply populates an initial db with data.
OpenIdUserDetailsService is our implementation of spring UserDetailsService that uses our finder to query the db using openid and return the right employee which we've augmented to be a fully fledged UserDetails Object by implementing that interface.


package za.co.bsg.rnd.trf.openidlogin;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import org.apache.commons.codec.binary.Hex;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;
import za.co.bsg.rnd.trf.openidlogin.domain.Employee;
import za.co.bsg.rnd.trf.openidlogin.domain.EmployeeStatus;
import za.co.bsg.rnd.trf.openidlogin.domain.UserRole;

@Component
@Configurable
public class InsertTestData implements
ApplicationListener<contextrefreshedevent> {

public static final String PASSWORD = "password";

@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
init();
}

private void init() {
if (!Employee.findAllEmployees().isEmpty()) {
return;
}
Employee employeeAdminActive = new Employee();
employeeAdminActive.setUsername("user1");
employeeAdminActive.setPassword(hexSha256(PASSWORD));
employeeAdminActive.setUserRole(UserRole.ROLE_ADMIN);
employeeAdminActive.setStatus(EmployeeStatus.ACTIVE);
employeeAdminActive.setOpenIdIdentifier("https://you.myopenid.com/");
employeeAdminActive.persist();
Employee employee2 = new Employee();
employee2.setUsername("user2");
employee2.setPassword(hexSha256(PASSWORD));
employee2.setUserRole(UserRole.ROLE_USER);
employee2.setFirstName("Peter");
employee2.setLastName("Jones");
employee2.setStatus(EmployeeStatus.ACTIVE);
employee2.setOpenIdIdentifier("https://www.google.com/accounts/o8/id?id=your_id_goes_here");
employee2.persist();
Employee employee3 = new Employee();
employee3.setUsername("user3");
employee3.setPassword(hexSha256(PASSWORD));
employee3.setUserRole(UserRole.ROLE_USER);
employee3.setFirstName("Christina");
employee3.setLastName("Applegate");
employee3.setStatus(EmployeeStatus.RESIGNED);
employee3.persist();
}



private String hexSha256(String password2) {
MessageDigest md;
try {
md = MessageDigest.getInstance("SHA-256");
md.update(password2.getBytes());
byte byteData[] = md.digest();
return new String(Hex.encodeHex(byteData));

} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return password2;
}
}
package za.co.bsg.rnd.trf.openidlogin;

import org.springframework.security.authentication.DisabledException;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import za.co.bsg.rnd.trf.openidlogin.domain.Employee;

import java.util.List;

public class OpenIdUserDetailsService implements UserDetailsService {

 public UserDetails loadUserByUsername(String openIdIdentifier) {
     List<employee> employeeList =
             Employee.findEmployeesByOpenIdIdentifier(openIdIdentifier).getResultList();
     Employee employee = employeeList.size() == 0 ? null : employeeList.get(0);

     if (employee == null) {
         throw new UsernameNotFoundException("User not found for OpenID: " + openIdIdentifier);
     } else {
         if (!employee.isEnabled()) {
             throw new DisabledException("User is disabled");
         }
         return employee;
     }
 }

}


/*Now make sure Employee.java implements the UserDetails Interface.

public class Employee implements UserDetails


and add the following interface method implementations.
(you need to leave roo running to correct the aspect j getters for username and password.)
*/

@Override
public String getUsername() {
 return this.username;
}

@Override
public String getPassword() {
 return this.password;
}

@Override
public boolean isAccountNonExpired() {
 return true;
}

@Override
public boolean isAccountNonLocked() {
 return true;
}

@Override
public boolean isCredentialsNonExpired() {
 return true;
}

@Override
public boolean isEnabled() {
 return this.status == EmployeeStatus.ACTIVE;
}

@Override
public Collection getAuthorities() {
 Collection grantedAuthorities = new HashSet();
 grantedAuthorities.add(
         new GrantedAuthorityImpl(this.userRole.name()));
 return grantedAuthorities;
}


in applicationContext-securtity
change
        <intercept-url pattern="/**" access="permitAll" />
to 
        <intercept-url pattern="/" access="permitAll" />
        <intercept-url pattern="/login/**" access="permitAll" />
        <intercept-url pattern="/**" access="isAuthenticated()" />
        <openid-login authentication-failure-url="/login?login_error=t" user-service-ref="openIdUserService" />


and change 
         <user-service>
             <user name="admin" password="8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918" authorities="ROLE_ADMIN"/>
          <user name="user" password="04f8996da763b7a969b1028ee3007569eaf3a635486ddab211d512c85b9df8fb" authorities="ROLE_USER"/>
      </user-service>

to 

      <jdbc-user-service
    data-source-ref="dataSource"
    users-by-username-query=
                        "SELECT
                            U.username,
                            U.password,
                            U.status = 'ACTIVE'
                         FROM
                            employee U
                         WHERE
                            U.username=?"
    authorities-by-username-query=
                        "SELECT
                            U.username,
                            U.user_role as authority
                         FROM
                            employee U
                         WHERE
                            U.username=?" />


after </authentication-manager> add:
 <beans:bean id="openIdUserService" class="za.co.bsg.rnd.trf.openidlogin.OpenIdUserDetailsService" />


add the google and open id form actions to the autogenerated login.jspx after </util:panel>

 <spring:url value="/j_spring_openid_security_check" var="form_url_openid" />
  <spring:url var="google" value="/resources/images/google-account-logo.png" />
  <spring:url var="openid" value="/resources/images/openid-logo.png" />

  <util:panel id="title_google" title="Google Login" >
    <img src="${google}" style="float:right" />
    <p style="height:0.25em"/>
    <form action="${fn:escapeXml(form_url_openid)}" method="post">
        <input name="openid_identifier" size="50"
               maxlength="100" type="hidden"
               value="http://www.google.com/accounts/o8/id"/>
        <div class="submit">
           <input id="proceed_google" type="submit" value="Sign in with Google" />
        </div>
    </form>
    <br/>
    <p/>
  </util:panel>

  <util:panel id="title_openid" title="OpenID Login" >
    <a href="http://openid.net/get-an-openid/" target="_blank" title="Where do I get one?">
        <img src="${openid}" style="float:right" />
    </a>
    <p/>
    <form action="${fn:escapeXml(form_url_openid)}" method="post">
       <div>
            <label for="openid_identifier">OpenID</label>
            <input id="openid_identifier" name="openid_identifier" type="text" style="width:150px" />
        </div>
        <br/>
        <div class="submit">
            <input id="proceed_openid" type="submit" value="${fn:escapeXml(submit_label)}" />
        </div>
    </form>
  </util:panel>

## Just change you.myopenid.com to whatever provider you prefer for that user in the insert test data method and you are good to go.

0 to RestFul Resource in 17seconds.

2011-03-29T18:11:00.000-07:00

Lets see some rails people figure out how to do this as dead simply as in spring-roo on java.

spring-roo commands:

mkdir myrestful_resource
cd myrestful_resource
roo
project --topLevelPackage com.my.web.my.restful.resources
persistence setup --provider HIBERNATE --database HYPERSONIC_IN_MEMORY
entity --class ~.domain.Resource1
field string --fieldName myfirstfield
field string --fieldName mysecondfield
controller all --package ~.controllers
osgi start --url http://spring-roo-addons.googlecode.com/files/net.tzolov.httprepresentations.roo.addon-1.1.7.jar
http resource representation setup
http resource add oxm --class ~.domain.Resource1
exit

json/html conversion works out of the box without modification however you need to annotate the model objects you want converted to xml by jaxb with @XmlRootElement so it knows what you want returned.

vi src/main/java/com/my/web/my/restful/resources/domain/Resource1.java

mvn tomcat:run

open up http://localhost:8080/resources in your browser and create some data on the auto-generated controllers.

access it via your browser or curl by simply appending .json .xml extensions to the url.

curl http://localhost:8080/resources/resource1s/1.json
curl http://localhost:8080/resources/resource1s/1.xml
curl http://localhost:8080/resources/resource1s/1.html

Pow!

also check out this springsource post about hitting json rest based services with curl.
http://www.springsource.org/roo/guide?w=base-json

Binary Trees In Java - Non Recursively Revisited

2011-02-03T15:47:00.000-08:00

The following is a demonstration of simple Binary Search Tree traversals in Java working off the following diagram. Simple recursive call solutions exist and are often used but they can create a rather large call stack for large binary trees.
Here I've instead favored finding non-recursive solutions for the standard BFS, and 3 types of DFS (preorder, inorder, postorder) which are a little trickier to understand but result in easier memory management for large trees.

To follow along download the 6k source for this article:
TreeTraversal.tar.gz

#unzip:
tar -zxvf TreeTraversal.tar.gz

#configure the eclipse project using maven:
mvn eclipse:eclipse

then simply import as an existing project into eclipse

    1 package Prep.TreeTraversal;
    2 
    3 import java.util.ArrayList;
    4 import java.util.HashSet;
    5 import java.util.LinkedHashSet;
    6 import java.util.List;
    7 import java.util.Queue;
    8 import java.util.Set;
    9 import java.util.Stack;
   10 import java.util.concurrent.ConcurrentLinkedQueue;
   11 
   12 import lombok.ToString;
   13 
   14 import org.apache.log4j.Logger;
   15 
   16 @ToString
   17 public class TreeTraversal {
   18 
   19     private Set<Node> treeNodes = new LinkedHashSet<Node>();
   20     static Logger log = Logger.getLogger(TreeTraversal.class);
   21 
   22     // Node Struct
   23     public class Node {
   24         // -- yes i know public fields - suck it, this is only a Struct.
   25         public Node parent;
   26         public Node self;
   27         public String name;
   28         public Node leftChild;
   29         public Node rightChild;
   30         public Node(String name) {
   31             this.name = name;
   32         }
   33         public String toString() {
   34             return this.name;
   35         }
   36     }
   37 
   38     // traversal methods
   39     //
   40     public List<String> bfsTraversal() {
   41         // basically this uses a queue (first in first out)
   42         // step 1. start by queuing the root node
   43         // step 2. dequeue the first element.
   44         // step 2.5 process it/ add it to the traversal list/ whatever you're
   45         // trying to do
   46         // step 3. enqueue its children in order left then right if they exist.
   47         // step 4. return to step 2 if queue still has elements
   48         Queue<Node> queue = new ConcurrentLinkedQueue<Node>();
   49         queue.add(getRoot());
   50         ArrayList<String> result = new ArrayList<String>();
   51         while (!queue.isEmpty()) {
   52             Node thisNode = queue.remove();
   53             log.debug("processing " + thisNode.name);
   54             result.add(thisNode.name);
   55             if (thisNode.leftChild != null) {
   56                 queue.add(thisNode.leftChild);
   57             }
   58             if (thisNode.rightChild != null) {
   59                 queue.add(thisNode.rightChild);
   60             }
   61         }
   62         return result;
   63     }
   64 
   65     public List<String> dfsPreorderTraversal() {
   66         // uses a stack (last in first out).
   67         // step 1. push the root node
   68         // step 2. pop the next node & process it, print it, whatever you like
   69         // step 3. push the right_child then the left_child if either exist.
   70         // step 4. repeat step 2 till stack is empty.
   71         Stack<Node> mystack = new Stack<Node>();
   72         mystack.push(getRoot());
   73         ArrayList<String> result = new ArrayList<String>();
   74         while (!mystack.isEmpty()) {
   75             Node thisNode = mystack.pop();
   76             log.debug("processing " + thisNode.name);
   77             result.add(thisNode.name);
   78             if (thisNode.rightChild != null) {
   79                 mystack.push(thisNode.rightChild);
   80             }
   81             if (thisNode.leftChild != null) {
   82                 mystack.push(thisNode.leftChild);
   83             }
   84         }
   85         return result;
   86     }
   87 
   88     public List<String> dfsInorderTraversal() {
   89         // uses a stack (last in first out).
   90         // step 1. push the root node and all left sub-children
   91         // step 2. pop the next node & process it, print it, whatever you like
   92         // step 3. if there is a right_child push it and all it's left
   93         // sub-children onto the stack.
   94         // step 4. repeat step 2 till stack is empty.
   95         Stack<Node> mystack = new Stack<Node>();
   96         for (Node node : getAllLeftSubChildresn(getRoot())) {
   97             mystack.push(node);
   98         }
   99         ArrayList<String> result = new ArrayList<String>();
  100         while (!mystack.isEmpty()) {
  101             Node thisNode = mystack.pop();
  102             log.debug("processing " + thisNode.name);
  103             result.add(thisNode.name);
  104             if (thisNode.rightChild != null) {
  105                 for (Node node : getAllLeftSubChildresn(thisNode.rightChild)) {
  106                     mystack.push(node);
  107                 }
  108             }
  109         }
  110         return result;
  111     }
  112 
  113     public List<String> dfsPostorderTraversal() {
  114         // uses a stack (last in first out).
  115         // step 1. push the root node and all left sub-children
  116         // step 2. peek at the top of the stack
  117         // step 3. if that node has an unvisited right_child add it and all its
  118         // left sub-children
  119         // step 4. else pop it, mark it visited and process it.
  120         // step 5. repeat step 2 till stack is empty.
  121 
  122         Stack<Node> mystack = new Stack<Node>();
  123         for (Node node : getAllLeftSubChildresn(getRoot())) {
  124             mystack.push(node);
  125         }
  126         ArrayList<String> result = new ArrayList<String>();
  127         Set<Node> visited = new HashSet<Node>();
  128         Node thisNode;
  129         while (!mystack.isEmpty()) {
  130             thisNode = mystack.peek();
  131             if (thisNode.rightChild != null
  132                     && !visited.contains(thisNode.rightChild)) {
  133                 for (Node node : getAllLeftSubChildresn(thisNode.rightChild)) {
  134                     mystack.push(node);
  135                 }
  136             } else {
  137                 log.debug("processing " + thisNode.name + ", curr stack: "
  138                         + mystack);
  139                 thisNode = mystack.pop();
  140                 visited.add(thisNode);
  141                 result.add(thisNode.name);
  142             }
  143         }
  144         return result;
  145     }
  146 
  147     // Tree helper methods
  148     //
  149     public Node getRoot() {
  150         for (Node node : treeNodes) {
  151             if (node.parent == null) {
  152                 return node;
  153             }
  154         }
  155         throw new RuntimeException("These nodes don't form a valid tree since there is no root");
  156     }
  157 
  158     private List<Node> getAllLeftSubChildresn(Node root) {
  159         ArrayList<Node> result = new ArrayList<Node>();
  160         result.add(root);
  161         while (root.leftChild != null) {
  162             result.add(root.leftChild);
  163             root = root.leftChild;
  164         }
  165         return result;
  166     }
  167 
  168     public Set<Node> getTreeNodes() {
  169         return treeNodes;
  170     }
  171 
  172 }
  173

And some test cases:

    1 package Prep.TreeTraversal;
    2 
    3 import java.util.Arrays;
    4 import java.util.List;
    5 
    6 import junit.framework.Assert;
    7 
    8 import org.apache.log4j.Logger;
    9 import org.junit.Before;
   10 import org.junit.Test;
   11 
   12 import Prep.TreeTraversal.TreeTraversal.Node;
   13 
   14 public class TreeTraversalTest {
   15 
   16     private TreeTraversal traversal;
   17     static Logger log = Logger.getLogger(TreeTraversalTest.class);
   18 
   19     @Before
   20     public void setUp() {
   21         traversal = new TreeTraversal();
   22 
   23         Node nA = traversal.new Node("A");
   24         Node nB = traversal.new Node("B");
   25         Node nC = traversal.new Node("C");
   26         Node nD = traversal.new Node("D");
   27         Node nE = traversal.new Node("E");
   28         Node nF = traversal.new Node("F");
   29         Node nH = traversal.new Node("H");
   30         Node nG = traversal.new Node("G");
   31         Node nI = traversal.new Node("I");
   32         
   33         nF.leftChild = nB;
   34         nF.rightChild = nG;             
   35         nB.leftChild = nA;
   36         nB.rightChild = nD;
   37         nG.rightChild = nI;
   38         nD.leftChild = nC;
   39         nD.rightChild = nE;
   40         nI.leftChild = nH;
   41         
   42         nA.parent = nB;
   43         nB.parent = nF;
   44         nC.parent = nD;
   45         nD.parent = nB;
   46         nE.parent = nD;
   47         nF.parent = null;
   48         nG.parent = nF;
   49         nH.parent = nI;
   50         nI.parent = nG;
   51         
   52         final Node[] nodesArr = {nA, nB, nC, nD, nE, nF, nG, nH, nI};
   53         traversal.getTreeNodes().addAll((Arrays.asList(nodesArr)));
   54 
   55     }
   56 
   57     @Test
   58     public void testBFS() {
   59         log.debug(traversal);
   60         List<String> actualOrder = traversal.bfsTraversal();
   61         String[] expectedOrder = {"F", "B", "G", "A", "D", "I", "C", "E", "H"};
   62         Assert.assertEquals(Arrays.asList(expectedOrder), actualOrder);
   63 
   64     }
   65     
   66     @Test
   67     public void testDFSPreorder() {
   68         log.debug(traversal);
   69         List<String> actualOrder = traversal.dfsPreorderTraversal();
   70         String[] expectedOrder = {"F", "B", "A", "D", "C", "E", "G", "I", "H"};
   71         Assert.assertEquals(Arrays.asList(expectedOrder), actualOrder);
   72 
   73     }
   74 
   75     @Test
   76     public void testDFSInorder() {
   77         log.debug(traversal);
   78         List<String> actualOrder = traversal.dfsInorderTraversal();
   79         String[] expectedOrder = {"A", "B", "C", "D", "E", "F", "G", "H", "I"};
   80         Assert.assertEquals(Arrays.asList(expectedOrder), actualOrder);
   81 
   82     }
   83     
   84     @Test
   85     public void testDFSPostorder() {
   86         log.debug(traversal);
   87         List<String> actualOrder = traversal.dfsPostorderTraversal();
   88         String[] expectedOrder = {"A", "C", "E", "D", "B", "H", "I", "G", "F"};
   89         Assert.assertEquals(Arrays.asList(expectedOrder), actualOrder);
   90 
   91     }
   92     
   93 }
   94

Announcing Software-Licensing-System-for-Ubercart a Drupal Module!

2010-12-05T14:36:00.000-08:00

Available here:
http://github.com/Thamster/Software-Licensing-System-for-Ubercart

- About this module:
This Drupal module allows someone who uses Ubercart to sell a software license
and generate license keys by having their application, written in any language,
communicate back to their Drupal site to retrieve and or generate SSL keys over http
in a secure manner with a simple set of usage limitations.

This is my first module release for Drupal.
Any refactoring or code style suggestions are highly encouraged.
thamster20 at gmail dot com

This module was build for drupal 6, which is the version i was using when writing this,
however I didn't code any specific function that would not work with other drupal versions.
Testers for other drupal versions are more than welcome to contact me.

This module is made for people with at least a rudimentary understanding of php code and ssl
keypairs. Part of the security of this system is in the customization you add to the code
yourself. The unique tokens you choose to use and hash/obfuscation algorithms you can optionally
add make this harder to crack.
Think of this as a functional baseline implementation you can tailor to your own security needs.

In time I may try to dummy proof the install but for now you'll probably need to read a bit of code
to get this to work for you properly.
Code submissions for improvements are also welcome.

This module depends on the following ubercart core modules.
Cart, Conditional Actions, Order, Product, Token, Store

- High Level Design of the Ubercart software licensing system:

Server Side:
Sets up a simple keygen php page to listen for http get requests from your software product.
The required get request parameter is named "data" and
should be a unique string identifying the purchased software license.
for example: customer_name combined with macaddress, email and order_number
You can use any unique string you like. This request parameter can be sent
from your software application in the clear or hashed beforehand, whatever your preference.
It is not necessary for it to be a secret based on how keypair ssl works.
Verifies that a ubercart order matching the keygen request exists and has been paid for.
Verifies a revocation list in revoked_license_t for licenses you no longer wish to generate keys for.
(in case of a refunded order for example)
Verifies if a key has already been returned for this specific unique identifying string.
if so looks up the previously generated key and returns that instead of generating a new key.
Verifies if the usage limit is exceeded. (counting entries in the license_t matching that order)
In this version we default to maximum 5 keys generated per year for a given order.
If the above verifications pass it then generates a license key using a 2048 bit ssl public/private
keypair you place on the server in a protected directory that isn't web accessible.
It then stores the key in license_t to keep track of usage limits.
A simple http text response is returned to be parsed by your software application.

Step 1.
Place the uc_license_key_system in the standard /sites/all/modules folder.
Step 2.
Run the drupal module installer from the admin page of your site. This will create
the necessary databases.
Step 3.
Create a new content page from the admin section of drupal and paste in the
contents of the page.ph_p file. (you can of course tailor it to your needs before hand)
* be sure to set the page's content type to "php code".

Client Side:

You need to implement this yourself in whatever language your software application is written.
I personally have my clients enter their order email and order number into a trial
application they download from my website to unlock the full version.
You can obviously change that around to be a downloaded key or some file
they place in a certain folder or whatever you like. We just need a way of linking the user
to the order placed in ubercart in a unique manner.
If the user shares their information with others they will run out of licenses
and that is how you will prevent piracy of your software product.

Step 1.
Create a unique string identifying your user.
ex: "order_num:email@address.com:mac:address:username";
Step 2.
Send a request to the above mentioned server php file to retrieve a license key.
Step 3.
Verify the response using the public key (which you store somewhere in your app).
The public key can be hardcoded or obfuscated completely up to you.
You just have to make it hard for pirates to swap in their own public key to
crack your software.
The difficulty of this step varies depending on the language you coded in.
For Example, in C++ a great writeup on this is here:
http://www.zabkat.com/blog/27Jun10-openssl-keygen.htm
Step 4.
Once a successful verification takes place you should store the license somewhere in the
app to remove the need to query the server for your license every time you want to
verify it. Alternatively you can permanently unlock the software after the first
successful verification completely up to you.

Customization:
Here are a few things you will need or want to change.
in file uc_license_key_system.module:
line 105:
$filename = "/home/you/yoursite.com/openssl/private.pem";
#(change this to the safe non web accessible location of your private key on the server)
line 94:
$result = array(
"email" => $tokens[0],
"order_num" => $tokens[1],
"mac_addr" => $tokens[2],
"username" => $tokens[3],
);
#(make this reflect the tokens you chose to be your unique identification string, if different)
line 91:
print t(" status : Error: Please contact customersupport@yoursite.com \n key : \n");
#(put in your own customer support address or just remove the line)
line 19:
$usage_limit = 5; //times per year per order
#(set this to whatever you want the yearly license limit to be).
line 22:
AND n.create_date > \'%s\'', $order_number, strtotime("1 year ago"));
#(change this to be whatever time limit you prefer)