package org.mccv
 
import java.net.URL
 
class CheckedEraser{
  def getProtocol(urlStr:String):String = {
    val url = new URL(urlStr)
    url.getProtocol
  }
}

package org.mccv;
 
import orc.mccv.CheckedEraser;
 
import java.net.URL;
import java.net.MalformedURLException;
 
public class CheckedJava {
    public String getProtocol(String urlStr)
    throws MalformedURLException{
        URL u = new URL(urlStr);
        return u.getProtocol();
    }
}

package org.mccv;
 
import orc.mccv.CheckedEraser;
 
import java.net.URL;
import java.net.MalformedURLException;
 
public class CheckedCaller {
    public static void main(String [] args){
        String urlStr = "www.google.com";
        String protocol = null;
 
        // Scala
        System.out.println("trying with Scala...");
        CheckedEraser ce = new CheckedEraser();
        protocol = ce.getProtocol(urlStr);
    }
}

        try{
            protocol = ce.getProtocol(urlStr);
        }catch(MalformedURLException e){
            System.out.println("caught an exception of type " 
               + e.getClass().getName());
            e.printStackTrace();
        }

package org.mccv;
 
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.TTransportException;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.TException;
import org.apache.cassandra.service.Cassandra;
import org.apache.cassandra.service.InvalidRequestException;
import org.apache.cassandra.service.UnavailableException;
 
import java.io.UnsupportedEncodingException;
 
public class CassandraJava {
    public void insertCassandra(String cassHost, int cassPort){
        try{
            // boilerplate to get Cassandra set up
            TSocket sock = new TSocket(cassHost, cassPort);
            TBinaryProtocol tr = new TBinaryProtocol(sock);
            Cassandra.Client c = new Cassandra.Client(tr,tr);
            sock.open();
 
            // run the inserts
            c.insert("MyTable","key","colFamily:colName1",
                    "foo".getBytes("UTF-8"),
                    System.currentTimeMillis(),false);
            c.insert("MyTable","key","colFamily:colName2",
                    "bar".getBytes("UTF-8"),
                    System.currentTimeMillis(),false);
            c.insert("MyTable","key","colFamily:colName3",
                    "baz".getBytes("UTF-8"),
                    System.currentTimeMillis(),false);
        }catch(TTransportException e){
            e.printStackTrace();
        }catch(TException te){
            te.printStackTrace();
        }catch(InvalidRequestException ire){
            ire.printStackTrace();
        }catch(UnavailableException ue){
            ue.printStackTrace();
        }catch(UnsupportedEncodingException uee){
            uee.printStackTrace();
        }
    }
}

package orc.mccv
 
import org.apache.thrift.transport.{TSocket,TTransportException}
import org.apache.thrift.protocol.TBinaryProtocol
import org.apache.thrift.TException
import org.apache.cassandra.service.{Cassandra,
  InvalidRequestException,UnavailableException}
 
object CassandraScala{
  // create a transparent conversion of strings to byte arrays
  private implicit def string2ByteArray(s: String): Array[Byte] =
    s.getBytes("UTF-8")
 
  def cassInsert(cassHost:String,cassPort:Int) = {
    // boilerplate to get cassandra set up
    val sock = new TSocket(cassHost, cassPort)
    val tr = new TBinaryProtocol(sock)
    val c = new Cassandra.Client(tr,tr)
    sock.open
    // run the inserts
    c.insert("MyTable","key","colFamily:colName1",
            "foo",System.currentTimeMillis(),false)
    c.insert("MyTable","key","colFamily:colName2",
            "bar",System.currentTimeMillis(),false)
    c.insert("MyTable","key","colFamily:colName3",
            "baz",System.currentTimeMillis(),false)
  }
}

package orc.mccv
 
import org.apache.thrift.transport.{TSocket,TTransportException}
import org.apache.thrift.protocol.TBinaryProtocol
import org.apache.thrift.TException
import org.apache.cassandra.service.{Cassandra,
  InvalidRequestException,UnavailableException}
 
object CassandraScala{
  // create a transparent conversion of strings to byte arrays
  private implicit def string2ByteArray(s: String): Array[Byte] =
    s.getBytes("UTF-8")
 
  def cassInsertCurried(cassHost:String,cassPort:Int) = {
    // boilerplate to get cassandra set up
    val sock = new TSocket(cassHost, cassPort)
    val tr = new TBinaryProtocol(sock)
    val c = new Cassandra.Client(tr,tr)
    sock.open
    // create a partially applied function with our
    // default arguments in place
    val insert = c.insert("MyTable","key",_:String,_:String,
      System.currentTimeMillis(),false)
    insert("colFamily:colName1","foo")
    insert("colFamily:colName2","bar")
    insert("colFamily:colName3","baz")
  }
}

            <ColumnFamily ColumnSort="Time" Name="Statuses"/>

        <dependency>
            <groupId>org.scala-tools.testing</groupId>
            <artifactId>specs</artifactId>
            <version>1.5.0</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.4</version>
            <scope>test</scope>
        </dependency>

package org.mccv.cassandra
 
import org.specs._
import org.specs.runner._
/**
 * Created by IntelliJ IDEA.
 * User: mmcbride
 * Date: Jul 24, 2009
 * Time: 10:43:31 AM
 * To change this template use File | Settings | File Templates.
 */
 
class cassandraTest extends JUnit4(BasicCassandra)
 
object BasicCassandra extends Specification {
  val cass = Cassandra("localhost",9160)
  doBefore {
    cass.connect()
  }
  doAfter {
    cass.close()
  }
  "Cassandra(\"localhost\",9160)" should {
    setSequential()
    "create a Cassandra instance" in {
      cass must_!= null
    }
    "provide for creation of a Db" in {
      cass.db("SocialGraph") must_!= null
    }
    "allow insertion of values" in {
      cass.insert("SocialGraph","mccv","Details:name","Mark McBride".getBytes("UTF-8"))
    }
  }
 
  "cass.Db(\"SocialGraph\")" should {
 
  }
}

package org.talkingpuffin.twitter
 
object ShowAPI {
 
  def main(args: Array[String]) = {
    // set up our credentials and session
    val user = "foo"
    val password = "bar"
    val sess = TwitterSession(user,password)
    // same method as before
    var friendsTweets = sess.getFriendsTimeline();
    System.out.println("got " + friendsTweets.size + " tweets from old style method")
    // use per page count
    friendsTweets = sess.getFriendsTimeline(TwitterArgs.maxResults(200))
    System.out.println("got " + friendsTweets.size + " tweets using per page count")
    // use chained twitter args
    friendsTweets = sess.getFriendsTimeline(TwitterArgs.maxResults(200).page(2))
    System.out.println("got " + friendsTweets.size + " tweets using chained twitter args")
  }
}

val args = TwitterArgs.maxResults(200)

val args = oldArgs.page(2)

package org.talkingpuffin.twitter
 
object ShowAPI {
 
  def main(args: Array[String]) = {
    // set up our credentials and session
    val user = ""
    val password = ""
    val sess = TwitterSession(user,password)
 
    // demo load all... this just loads the first page
    var myTweets = sess.getUserTimeline("mccv")
    System.out.println("got " + myTweets.size + " tweets from my timeline")
    // now we show load all.  loadAll just wants a function that takes an int as an arg,
    // which is the page.  Scala's partially applied functions make this pretty easy
    // to use in a general purpose way
    myTweets = sess.loadAll(sess.getUserTimeline("mccv",_:Int))
    System.out.println("got " + myTweets.size + " tweets using loadAll")
    // this is even fancier.  Here I add retry logic to load all.
    // note that retryPage is a function I defined here... but the session
    // doesn't care.  It keeps iterating through pages, retrying and loading
    // until it reaches the end.
    myTweets = sess.loadAll(retryPage(_:Int,sess.getUserTimeline("mccv",_:Int)))
    System.out.println("got " + myTweets.size + " tweets using loadAll and retries")
  }
 
    /**
    * this is a function that is sort of a thunk through to tryNTimes.
    */
    def retryPage[T](page:Int, func: (Int) => T):T = {
        // here we define a privately scoped function
        // that can be passed to tryNTimes
        def tryPage() = {
            func(page)
        }
        // and now we try N (5) times
        tryNTimes(tryPage,5)
    }
 
    /**
    * from the last blog post, a retrier
    */
    def tryNTimes[T](func: () => T, runNumber: Int):T = {
      try{
          func()
      } catch {
        case e if runNumber > 1 => tryNTimes(func,runNumber - 1)
        case e => throw e
      }
    }
 
}

sess.getUserTimeline("mccv",_:Int)

package org.mccv;
 
import java.util.concurrent.Callable;
 
/**
 * The implementation of our retrying class
 */
public class Retryer<T> {
	/**
	 * The retryable we will call
	 */
	private Callable<T> retryable;
 
	/**
	 * Just assign our retryable field 
	 */
	public Retryer(Callable<T> retryable){
		this.retryable = retryable;
	}
 
	/**
	 * Try to execute our retryable n times 
	 */
	public T tryTimes(int times) throws Exception{
		// store the last thrown recoverable exception
		RecoverableException lastException = null;
		// try the specified number of times
		for(int i = 0; i < times; i++){
			System.out.println("running it with " + (times-i) + " tries remaining");
			try{
				return retryable.call();
			}catch(RecoverableException re){
				lastException = re;
			}
		}
		throw lastException;
	}
}

package org.mccv;
 
import java.util.concurrent.Callable;
 
/**
 * An implementation of the Retryable interface
 */
public class RetryableImpl implements Callable<String>{
	/**
	 * Show usage of the retryer
	 */
	public static void main(String [] args){
		// create a new retrier
		Retryer<String> retrier = new Retryer<String>(new RetryableImpl());
		// run the retrier 
		try{
			System.out.println("result = " + retrier.tryTimes(3));
		}catch(Exception e){
			System.out.println("failed after 3 tries");
		}
	}
 
	/**
	 * An intentionally flaky operation
	 */
	public String call() throws Exception{
	    if(Math.random() > 0.3){
	        throw new RecoverableException();
	      }else{
	        return "foo";
	      }
 
	}
}

package org.mccv;
 
/**
 * A marker class for recoverable exceptions
 */
public class RecoverableException extends Exception{
 
}

package org.mccv;
 
/**
 * An interface that defines an execute operation to retry
 */
public interface Retryable<T> {
	public T execute() throws Exception;
}

package org.mccv;
 
/**
 * The implementation of our retrying class
 */
public class Retryer<T> {
	/**
	 * The retryable we will call
	 */
	private Retryable<T> retryable;
 
	/**
	 * Just assign our retryable field 
	 */
	public Retryer(Retryable<T> retryable){
		this.retryable = retryable;
	}
 
	/**
	 * Try to execute our retryable n times 
	 */
	public T tryTimes(int times) throws Exception{
		// store the last thrown recoverable exception
		RecoverableException lastException = null;
		// try the specified number of times
		for(int i = 0; i < times; i++){
			System.out.println("running it with " + (times-i) + " tries remaining");
			try{
				return retryable.execute();
			}catch(RecoverableException re){
				lastException = re;
			}
		}
		throw lastException;
	}
}

package org.mccv;
 
/**
 * An implementation of the Retryable interface
 */
public class RetryableImpl implements Retryable<String>{
	/**
	 * Show usage of the retryer
	 */
	public static void main(String [] args){
		// create a new retrier
		Retryer<String> retrier = new Retryer<String>(new RetryableImpl());
		// run the retrier 
		try{
			System.out.println("result = " + retrier.tryTimes(3));
		}catch(Exception e){
			System.out.println("failed after 3 tries");
		}
	}
 
	/**
	 * An intentionally flaky operation
	 */
	public String execute() throws Exception{
	    if(Math.random() > 0.3){
	        throw new RecoverableException();
	      }else{
	        return "foo";
	      }
 
	}
}

package org.mccv
 
/**
 * A marker trait indicating an exception that is recoverable.
 * Note that we could make this a trait as well.
 */
class RecoverableException extends Exception
 
/**
 * Usage of our retryable class
 */
object Retryer {
	/**
	* The workhorse.  Runs the operation, and if successful returns the result.
	* If unsuccessful calls itself recursively with a decremented run number.
	*/
	def tryNTimes[T](func: () => T, runNumber: Int):T = {
	  println("running it with " + runNumber + " tries remaining")
	  try{
		  func()
	  } catch {
	    case e:RecoverableException if runNumber > 1 => tryNTimes(func,runNumber - 1)
	    case e => throw e
	  }
	}
}
 
object Main {
   def main(args: Array[String]):Unit = {
    val tries = 3;
    try{
    	println(Retryer.tryNTimes[String](flakyMethod,tries))
     }catch{
       case e => println("failed after " + tries + " tries")
     }
  }
 
  def flakyMethod():String = {
    if(Math.random > 0.3){
      throw new RecoverableException()
    }else{
      "foo"
    }
  }
}