Finding Slow Queries in MySQL

I have this web application I built. It's a test tool that performs a variety of checks of phone numbers and phone carriers. I noticed after a recent update that it began to load really slow (the web interface.) Instead of the usual 4 second load time, it was taking 30 seconds. I had indexed a variety of tables in the past, so I wasn't sure which query was causing the problem. What helped me find out the source of the problem was MySQL's slow log. In my default installation of MySQL, the slow logging is not on. To turn it on, I had to first edit the mysql config (which on Centos is somewhere like /etc/my.cnf) In the config file I added these lines under [mysqld]: log-slow-queries = /var/log/mysql/slow_query.log long_query_time = 10 log-queries-not-using-indexes Next, I created the folder /var/log/mysql and set the ownership to mysql: sudo chown mysql.mysql /var/log/mysql Inside the folder, I added a empty file: touch slow_query.log After doing all that, I restarted MySQL with /etc/init.d/mysql restart (which is the default CentOS way to restart mysql.) In the general mysql log (/var/log/mysqld.log) there should be no errors referencing the new slow log. The lines added to the my.cnf file basically say: when a query is slow, please log it in /var/log/mysql/slow_query.log by slow, I mean anything taking longer then 10 seconds also, log any queries not using an index. After restarting mysql and hitting the webpage, I saw the new slow log updated and found the culprit query causing my problems.

Groovy - say NO to FOR loops

Although for loops are part of Groovy, the each iterator is much more useful.  I just found this out from a developer at my job.

I have been doing a pretty big project. Part of the project involves having a grails application run a job every min. each time it runs this job, it will iterate through a set of IP's.  Each IP is a proxy that routes a telephone call. If the call completes it pass's, if it doesn't, we through a failure.  Each iteration needs to be stored in the database.

The problem was this....

I had a For loop that would create a new instance, then do the validation... But each run would replace the results in the db. 

By switching to an each closure, it resolved this.  Here's some example code of what worked:

ipprox = ["127.0.0.1","128.0.0.1","129.0.0.1"]


ipprox.each { prox -
def res = proxyCheckService.sipp(phone,proxy).result
def proxyCheckInstance = new ProxyCheck
 proxyCheckInstance.results = res
 proxyCheckInstance.dnis = dnis
 proxyCheckInstance.proxy = prox


if (res =~ /Successful call\s+9[0])\s+1/){
proxyCheckInstance.pass = "PASS"
 } else {
 proxyCheckInstance.pass="FAIL"
 }

 proxyCheckInstance.save(flush:true)

In this code, I no longer had the problem of iterating through a list and getting one db record at the end.  Now, the list is correctly being iterated through, each run gets it's own db row entry.

Thanks Yakoob for your help!

Grails - Setting Up Spring Security

This is pretty quick and Simple....

If you  have a new grails project, you may not need to do Step 2

Step 1: edit BuildConfig.groovy and in the plugins closure, add compile ':spring-security-core:1.2.7.3'

Step 2: if you have an existing project you may need to add this: grails.project.dependency.resolver = "maven" above the grails.project.dependency.resolution closure

Step 3: compile

Step 4: run this grails command on the project: s2-quickstart [your package] User Role

Step 5: Add a user to the bootstrap by editing your BootStrap.groovy file and adding after servletContext ->
def eventOwnerRole = new Role(authority: 'ROLE_EVENT_OWNER').save(flush:true)
def userRole = new Role(authority: 'ROLE_USER').save(flush:true)
def testUser=new User(username: 'me', enabled: true, password: 'password')
testUser.save(flush:true)

UserRole.create testUser, userRole, true

Step 6: in one of your controllers, add:
import [the package your user/role classes were put].Role
import [the package your user/role classes were put].User
import [the package your user/role classes were put].UserRole

Step 7: Edit an existing controller and add
import grails.plugins.springsecurity.Secured

@Secured(['ROLE_USER'])

Run the app... go to the controller... it should now prompt for user/pass...

Project: Making a SIP GUI test harness with Grails and SIPP - Part III

Part I, discussed this project and walked through setting up SIPP scenarios and Grails (making a basic Grails project.)

Part II, discussed adding in a Service Layer to do the SIPP call and added some call validation.

Now What?

So now what? Well you can add on to your test harness. You can add other domain classes, controllers and services as needed.

For example, what if you wanted to have a different interface, where a user just enters a phone number and a proxy, and the service not only uses sipp but iterates through a list of carriers?

You could do that by adding in a new Domain object, and generate controllers/views... then make a service to handle the logic.  Like in the service you might define a list:
def carriers = ['Sprint','TCast','Verizon'] and iterate through it with a for loop, like:

for (c in carriers) {
     def carrier = c
     def dialNum = "sipp -s ${dnis} ${ipprox} -sf ${carrier}_outbound_call.xml -l 1 -m 1 -d 5000".execute().text
 .... 

Or what if you wanted a Service that would handle some audio analysis, so you could turn the audio of the phone call to a string and compare it against an expected value?  

You can keep adding onto the project with more and more cases.  

In the end, the code is centralized, and we have a UI for free. This UI can be used by us or other testers.

Tomcat

So lastly, there is the aspect of deployment.  For QA, we usually run our own servers and environments.  In my case, I have a variety of Linux Centos VM's available to me.  I basically put Tomcat up on one of those guys. 

I'm assuming you got Tomcat up and running, as I wont cover setting it up in this post.

To deploy a Grails application, you basically do what you would do in Java - you create a WAR file and drop the WAR file in the Tomcat webapp folder. 

So there's two ways I can think of doing this.... the hard way and the easy way.

The Hard Way

The hard way, basically means you do it the long way.  In this method, you simply open the grails command line in Intellij and type:
grails war
and hit enter or click ok.  

It will generate a war file and drop it in your project under /target.

Then you would SCP/FTP that up to your Tomcat server

That's not so hard.  But there's an easier way....

The Easy Way

First you need to set this up.  After that it's easy.  

The easy way is easy, because once it's set up, you don't do any FTP/SCP or WAR Generation. You just run a command and it does all that.  

To get here, you will first need to do a few things - 

On the Tomcat server, edit the tomcat-users.xml file.  In that file you want to add a role group (if you don't have it) called "manager-script."

Add a user with the role  manager-script... jot down the username and pass you gave it... you'll be adding that in the Grails configuration.

In Grails 2.2.4 Tomcat deployment plugin is already installed.  What you need to do is configure it so that when you deploy via your IDE, it will do all the WAR generation and SCP to your Tomcat server, for you.

**NOTE: I'm having issues with Grails 2.3Pre Release at this time, with Tomcat deployments**

In Grails, you open your /conf/Config.groovy file and add this:

/**
 * TOMCAT DEPLOY CONFIG
 */
tomcat.deploy.username="grails"
tomcat.deploy.password="pass"
tomcat.deploy.url="http://[your Tomcat server]/manager/text"
/**
 * END TOMCAT CONFIG
 */

That's it.  

Now to deploy to Tomcat, you do this command: grails tomcat deploy 
from the command line within the IDE. 

Project: Making a SIP GUI test harness with Grails and SIPP - Part II

In Part I, we set up SIPP, SIPP Scenarios and created a Grails application with a controller and a domain class.

What we'll start with in Part II is the creation of a service.

But first... what is a service?

A service is a piece of functionality that coordinates logic with the Domain layer. 

We'll use a service to run the all the logic that's needed for the application.  By separating the code out into a service, we move the logic into a layer that isn't the same as the controller.  If we didn't do this, the controller would be handling all the functionality.

Grails looks to split the core functionality and logic into a separate layer (i.e. Service layer) and leave the controller as handing the routing.  In this model of development the controller is left to return values, render values or redirect to a specific view or other controller.

So again, the 3 R's of controllers are:

• Render
• Redirect
• Return

Render is not a common use of a controller.  Returning values and Redirection is the most common activity of a controller.

So now that that's out there, what do we need to do with this service?

We need to put the logic in there, that handles the user input.  Remember our tool offers a UI that a end user can hit, pull up a form and submit a phone number, carrier and proxy.  We want those values to plug into SIPP, and let SIPP make the call and we'll validate if it's successful or not.

Service

To create a new service, in Intellij you can right click the project in the project tree, and then choose 

New | Grails Service

Give it a name... like DialerService

Great, now in the project tree, open the services folder.  You should see your new service listed there.  Go ahead and double click it to open it up.

Let's go ahead and add some logic in here. 

def sipp(phone,ipprox,carrier){
    def dialNum = "sipp -s ${phone} ${ipprox} -sf /carrierTests/outbound/${carrier}_outbound_call.xml -l 1 -m 1 -d 5000".execute().text
    [dialNumResult:dialNum]
    }
}

Let's review what's going on here.  

The service has a method called sipp, which takes three parameters (phone number, the proxy ip and the carrier) - these three parameters are the ones being passed in by the end user on the form.  

The sipp method has a piece of functionality defined as dialNum.  dialNum basically runs our SIPP command line call.  What's in quotes is the string we will execute.  The ${} is a gString... or groovy string.  Groovy strings are there to pull in those parameter values being passed through.  The .text() may not seem logical, but I actually want it there.  It will take the output from SIPP (with the call data) and convert that to text for us.  That way if someone says "ok the call went through, but how do I know what it did?" they can have a record of the actual call process.

Lastly, what's that square bracket stuff?

The square bracket is a return.  We are saying set up this variable dialNumResult to have the value of dialNum... and pass it back.

In Grails, the last line of a method is the last action returned.  In this case, we're returning the value of dialNum.  

Controller

Back in the controller, we want to pass the variables we are getting from the user input (via the form) through to the service we made.  

So under def outboundCallInstance = new OutboundCall(params) add these lines:

def carrier = params.carrier

def phone = params.phone

def ipprox = params.ipProxy

Great, so do you see how it's working? We're taking the user input on the form, which is going to the controller... and the controller is routing it to the service.  The service will do it's logic/functionality and return the result.  

But this isn't quite done yet.  We are grabbing the data from the form, sure enough, but we aren't passing it to the service.

Above the save method in the controller add this:

def dialerService

In Intellij, it will automatically know that this is a reference to the service we made and put a special icon next to it in the margin.  

Why did we reference the service in camel case, when it's really named DialerService?  Well that's just how you do it.  We're referencing the service in a class and this is how we do it.  

Below the lines we added (after the parmas.ipProxy line) add this line:

outboundCallInstance.results = dialerService.sipp(phone, ipprox, carrier).dialNumResult

If you set it up right it should auto complete a lot of that for you.  We're saying, hey we defined this service, now lets talk to it... we want the outbound call instance's results to be the dialer service and pass into it the 3 variables: 

• phone
• ipproxy
• carrier

...and we expect the dialNumResult returned (this is the output from sipp)

So it should look something like this:

def dialerService
    def save() {
        def outboundCallInstance = new OutboundCall(params)
        def carrier = params.carrier
        def phone= params.phone
        def ipprox = params.ipProxy
        outboundCallInstance.results = dialerService.sipp(phone, ipprox, carrier).dialNumRes

        ....

There will be other code in there, just leave it as it was generated.

To recap:
We are:

1. Collecting user input on a form
2. passing that to a controller that sends it on to a Service
3. The service does some logic on it and returns a result
4. All this is saved in the db

Validation

If you were to run this, it should make a single call via SIPP to your phone number via a proxy of some sort.  You can test this out by running the application again and filling out the form with valid data for your test environment.

But it's not really validating the phone call.  

First I'll show how to do some simple validation of the SIPP call with some logic in the controller... later on I'll show a different way to validate with some logic in the service.

Back in the controller, let's go to that save method again, and under the outboundCallInstance.results = line, let's add this if statement:

if (dialerService.sipp(dnis,ipprox,carrier).dialNumRes =~ //){
            outboundCallInstance.pass = "PASS"
        } else {
            outboundCallInstance.pass = "FAIL"
        }

This is pretty simple and it won't work. Not yet.  We haven't added the REGEX.

The IF statement is saying, IF the dialer service return =~  (that funny symbol means we're going to use Regular expressions here) // (and what's inside the slashes is what we look for.  If the regular expression matches, then we will assign the string value "PASS" to the Domain Class variable "pass" and if it fails the regular expression, we will assign the string "FAIL" to that Domain Class variable.

If you know SIPP output you know it's difficult to regex on.  This is because SIPP outputs it's results like this:
Successful Call   |0|1
Failed Call         |0|0

That's pretty crazy right?  Because if you make that a map, it would look like this:
Successful Call, 0, 1 Failed Call.

But it's not a failed call, it's a successful call!  Silly SIPP output!

Regex Hell

After many hours of Regular Expression Hell, I created this regex that works for SIPP results:
Successful call\s+([0])\s+1

It basically says, Look for the words Successful call, on the same line, find the 0, and the fond the 1.

That was my solution, yours might be better.

so now the controller should look like:

if (dialerService.sipp(dnis,ipprox,carrier).dialNumRes =~ /Successful call\s+([0])\s+1/){
            outboundCallInstance.pass = "PASS"
        } else {
            outboundCallInstance.pass = "FAIL"
        }

If you were to run this now, it will most likely fail.  Either pass when it should fail, or fail when it should pass. The reason, is the Pipes in the SIPP output.  I've tried a lot of solutions, including escaping the pipes in the Regex, but it still doesn't work right.

To fix it, we need to open the service and add this to the return:

[dialNumRes:dialNum.replaceAll("\\|", "")]

So at the end of dialNum, add a

.replaceAll("\\|", "")

This removes the pipes in the output.  So what's returned is returned without Pipes.

That should be it. It should work just like that. On to Part III (Deployment)

Project: Making a SIP GUI test harness with Grails and SIPP - Part I

Making a SIP GUI Test Harness - Part I

Introduction

Part I will cover:

• The Introduction
• Setting up SIPP scenarios
• Creating a Grails project
• Creating Grails Domain Classes and Controllers

In VOIP, the term SIP refers to Session Initiation Protocol.  It's a protocol that allows voice communication via online connections.  Many phone calls are themselves SIP at some point.

If you currently test SIP, you probably use tools like SIPP.  SIPP is the most common tool I know of. It's open source, very diverse in functionality, and has a large following of contributors.  SIPP is typically used to generate load tests - like driving 50 calls per second, to a switch.  But SIPP can also be used for functional tests as well.

Audience for this Tutorial

• SIPP is installed and running
• Familiar with some scripting/programming (I'll be very detailed on basics of groovy/grails)
• A basic understanding of automation
• A basic understanding of VOIP 
• You have an environment with a soft switch (FreeSwitch, Asterix... or a sip server like Berkeke, OpenSIPS, etc.) that we can route calls through.

End Results

By the end of this tutorial, you should have a working UI that will take a phone number and proxy (sip server) - dial the number via the proxy on submit and validate if the call passed or failed.  You will also have the foundation on which to build other test criteria, such as voice analysis and load testing.

Basically by the end of this demonstration you should be able to do this with Grails:

• Be able to create a Grails Project
• Know how to create controllers
• Know how to create services and why they're cool
• Set up Domain Classes

...and you'll be able to do this with VOIP / SIP:

• Create SIPP XML scenarios for Outbound carrier tests
• Run SIPP as a Functional Test Tool

SIPP Basics

While SIPP automates these phone calls, it's use is manual.   That is, you create a XML file that builds the scenario. You then type a command line, like:

sipp [phone number] [switch] -sf [path to xml scenario file] -l [limit the amount of calls to this value] -r [limit the rate of calls] -trace_err

SIP Automation

That's great for one off tests, what if you want something run often by a chron job or by other people who may not know SIPP's depth of command line properties?

What if you wanted to integrate functionality with SIPP to do things like Audio Analysis, or to iterate through a collection of tests?

That's why I created a test harness. 

My first SIP Test Harness was written with shell scripts.  It worked, but it put my work all over the place. I had one shell script to do a phone call, another to do complex audio analysis, another to do packet captures, etc.

I've improved on this, and in the process got a UI thrown in for free.  

What is Grails and Why Use It

Grails is a MVC architecture for Groovy. MVC stands for Model View and Controller.  It's a design system that offers a quick way to generate code.  It makes use of domain models, hibernate, plugins and much more - to give a rich tool set.

You'll get the UI for free.  Grails will generate UI's for you and we can modify the static scaffolding to suite our needs.

Groovy and Grails (much like Ruby and Rails) is very simplistic and will allow you to write complex applications with very little code.  You can parse JSON with a line of code, or generate CRUD (create, read, update, delete) actions instantly with a command line.  It's fast and rapid development that truly suits tools development.

Why Grails? Why not Rails?  
No particular reason.  The benefit of Grails is that it compiles down to Java Byte Code so it runs where there is Java. Also Java developers can easily read it ... and there is the benefit of having more people who can update the code as needed.  

Technology Used

• SIPP (make sure you have that installed - you'll need linux or MacOSX
• Tomcat (I'll use Tomcat, but you can feel free to use Jetty or something else)
• Grails (For grails you'll need Java installed, as well as groovy, and you'll want to have an IDE.  A free IDE is the Groovy Grails Tools Suite from SpringSource: http://www.springsource.org/groovy-grails-tool-suite-download A better choice IMO is the commercial version of Intellij.  But either will work.  This tutorial will use Intellij.
• SoftSwitch that we can route calls through (Asterix, FreeSwitch, etc.)

Test Harness Requirements

First, what do we want the test harness to do?  

For the purpose of this demonstration, I'm going to build out a test harness that will 

1. place calls 
2. validate if the call is a pass or failure.  
3. Then we'll build from there to iterate through a list of different call scenarios (like calling different carriers.)

We need to make sure the technology used is working... so:

• Make a test call with SIPP (dial a DNIS/phone number with an installed soft switch)
• Verify you have Tomcat or Jetty up and running
• Verify you have Grails avail., in a command prompt do a grails -version. 
• Verify your IDE is integrated with Grails (I.e. you can make a grails project)

If you can check off the four items in the above list, then we're good to go.

So let's start....

Create a Grails Project

To create a Grails project, just go to a directory on your local file system and do a 

grails create-app [name]  

Example:

 grails create-app siptesting

In your IDE load the project.

For example, in Intellij you would do a:

File | Import Project

Point it to the project you just created and accept the prompts it gives.

Once the project is loaded in the IDE, we'll create the domain class first.  The domain class will set the data elements we care about, any validation rules on them and these values will be stored in the db.

Speaking of Db, we could use any db we want, but for this demo, we'll just the in memory db (h2) that Grails defaults to.

To create a domain class in Intellij, you right click the project name, then click the sub menu item: New | Grails Domain Class

Give it a name like: OutboundCall

In the project tree, you should see a structure like:

grails-app

   > conf

   > controllers

   > domain

In domain there should be a class now, called OutboundCall, open that up.

It will probably look like this:

class OutboundCall {
   static constraints = {

   }
}

Under the class reference, we're going to define some values.  These values will tell Grails what to store.  The info in a domain class is also used to create scaffolding elements like controllers and views.  

By that I mean, if you define something in the Domain, Grails will generate all the actions to capture this data for you.  Which saves from writing a lot of structure from scratch.

So lets define some things we want to capture...

Under class OutboundCall {

Date dateCreated
String carrier
String results
String ipProxy
String phone
String pass

dateCreated is an internal function. It will add a timestamp to each save of data

carrier will be captured from user input

results will be a computed value

ipProxy will be captured from user input

phone will be captured from user input

pass will be a computed value

Below this, there is that closure called "static constraints"  - we want to add some constraints to the above variables.  For example, we are ok with date being nullable, and only be able to pick carriers from a defined list (dropdown...) 

So in the static constraints closure, add the following:

  
dateCreated nullable: true
carrier inList: ['Sprint','Verizon','Tcast']
results maxSize: 50000, nullable: true, display: false
ipProxy blank: false
phone blank: false
pass nullable: true, display: false

What we're saying here is this: 

dateCreated is nullable, but why? Because it's not a value on the user creation form. It's going to be calculated by Grails.  I had to make this nullable because otherwise Grails expects a value.  

carrier uses a inList. Everything in the square brackets is going to be a option in a dropdown in a form.

results - we are saying results will have a size limitation and it's also nullable, and it won't display.  The reason is that this field is going to be the SIPP output.  It can be large output and it's not user input.  We don't want it to display, except when it's avail, so not until the results are shown.

ipProxy and phone - are user input fields and they can't be blank.

pass - will be a value based on some logic to determine if the call went through fine or not.

Basically the Domain Class should look like this:

 
class OutboundCall{

    Date dateCreated
    String carrier
    String results
    String ipProxy
    String phone
    String pass


    static constraints = {
        dateCreated nullable: true
        carrier inList: ['Sprint','TCast','Verizon']
        results maxSize: 5000000, nullable: true, display: false
        ipProxy blank: false
        phone blank: false
        pass nullable: true, display: false
    }
    static mapping = {
        results type: 'text'
    }
}

Generating the Static Scaffolding

At this point, we've created the domain.  Lets do our first generation of code.  We want Grails to generate the Controllers (the part of the code that will route logic) and Views (the display portion of the code.)

In Intellij, you can do a control+alt+G (windows) or Mac equivalent to pull up a command line for grails. In the box you will send:
grails generate-all [packag name].[class name]

For example:
grails generate-all siptests.OutboundCall

This will generate a controller for you called OutboundCallController (under the controllers folder in the project tree) and a set of views in a folder called "outboundCall."  

Run the App

Let's see how our application looks.... go ahead and start it.

In Intellij we can click the green "play" like triangle at the top of the screen.  

It should load without issue.  Once it loads, it will give you a url, like http://localhost:8080/... click that link.  

Iniitally you will land on a page that Grails generates to show you all your plugins used in the project and has links to your controllers.  Click on the controller link.

This UI is all pre-built for you.  You can "create" and it will load a UI with the fields we set in the Domain class. Go ahead and put some data in there and save it.

You'll be back at the List, showing your data you just saved.

It's not doing anything yet, other then capturing user input.  But we can see that the applicaiton is up and running and taking user input.

Let's add some logic!

Controller

Go ahead and open up the controller we generated.

You'll see a lot of code.  There will be all your crud actions in there.  You'll see things like
def create() 
def save()
def show()

This is the basic functionality of creating, saving, showing your data....

Our goal here is to take a user's input, and pass it to SIPP and validate the results we get.  So we want to 

SIPP

Back in SIPP, lets create some test scenarios.... Grails is going to let users send the phone number, the proxy and the carrier for the test.  So lets get SIPP scenarios set up to handle this.

on the command line do a:

sipp -sd uac > outbound_call.xml

The above command will export a base template from SIPP to the XML file specified.

Once we have that file, lets edit it.  We need to specify the carriers.  In our example, we are going to allow users to send calls using Sprint, Verizon and TCast.  To make this simple, we'll create three XML scenario files - one for each carrier.  In each one, we'll hard code the carrier into the SIP Invite header.

If setting the carrier is applicable to you, you can define the carrier in the XML scenario.  If it isn't applicable to you, then just omit the carrier reference in Grails (in the domain class) and just capture the phone number and proxy.

Some people can hard code a carrier value like:

Carrier: SPRINT

which is mapped to rules in their Sip Server (Berkeke or OpenSIPS) to send the call to the appropriate carrier.

If that's of interest, then lets do it.... let's copy that template as three files:

sprint_outbound_call.xml, verizon_outbound_call.xml, tcast_outbound_call.xml

Edit each one and modify the carrier value you read in from your sip server to be hard coded to this value.  

Now when you run the sipp call to use this scenario it will be set to use this carrier - testing the carrier itself in handling the call.

Run a sipp scenario here that we made and make sure the call will go through to a phone number you have defined on the sip server.  

If it works... then continue to Part II (Part II will cover setting up a Service and updating the Controller as well as Validating the results.)

Grails - Creating an Auto Dialer - Refactored with Services

After getting some formal Grails training, I decided to refactor this tool I made for our internal provisioning team.

The Original tool was discussed previously here.

Don't Put Too Much Logic in the Controller

I learned that a good MVC practice is to not put too much logic/work in the controller - but to think of controllers as routers.  The body of logic should be pulled out into services.

My previous version of the tool had all the work in the controller.  I had one controller doing this:

• Parsing a user submitted CSV file
• Dialing each number in the CSV
• Emailing the results of each number being active or disconnected, to the requested email

I've changed this, so that the controller just does CSV parsing, and two separate services are handing the phone number dialing and the email sending.

The Refactored Controller

The controller now looks like this:

@Grab('com.xlson.groovycsv:groovycsv:1.0')
import static com.xlson.groovycsv.CsvParser.parseCsv


class CsvImportController {
    def emailService
    def dialerService

    def save() {

  def emailTo = params.emailAdd
  if (emailTo =~ /@myinternaldomain/) {
  def csv = request.getFile('myfile').inputStream.text
  
  def data = parseCsv(csv)

  runAsync{
   for(line in data) {
             def phone = line.Phone
            dialerService.dialNumber(phone)
   
   }
   
            emailService.sendingEmail(emailTo)

   }
  }else{
   render(view:"error") {
     div(id:"error", "E-mail Format Error: E-mail must be from @myinternaldomain.com")
    }
  }
 }
}

The two service calls (dialerService.dialNumber(phone) and emailService.sendingEmail(emailTo), now clean up the controller quite a bit.

Services

There are two new services now:
DialerService and EmailService

The DailerService looks like this:

class DialerService {

    def dialNumber(String phone) {

        println "Trying... $phone"
        def dialNum = "sipcli/sipcli.exe $phone -d [proxy ip goes here] -o 4 -t \"This is a test. this is a test. this is a test. this is a test\"-l 3".execute()
        def outFile = new File("grails-app/test.txt")
        if (dialNum.text =~ /success/){
            outFile << ("PASS on number $phone\r\n")

        } else {
            System.getProperty("line.separator")
            outFile.append("FAIL  on number $phone\r\n")

        }
    }
}

The EmailService looks like this:

class EmailService {

    def sendingEmail(String emailTo) {
        println "Emailing Report To: " + emailTo
        sendMail {
            multipart true
            to "${emailTo}"
            from "brian@someemail.com"
            subject "Provisioning Report"
            body 'Please find the attached Provisioning Report...'
            attachBytes 'grails-app/test.txt','text/csv', new File('grails-app/test.txt').readBytes()
        }
        println "Attempting to delete results file..."
        def delFile = new File("grails-app/test.txt").delete()
    }
}

GRAILS - Dynamic Scaffolding and MYSQL Set Up

Part of my development learning, I put together some notes on Grails. In this post, it covers mostly the use of dynamic scaffolding and the connection to a mysql server, as well as the use of environments. 

Scaffolding is the MVC format seem in Rails and Grails. It allows a developer to set up CRUD (Create/Update/Delete) actions super fast.   Dynamic Scaffolding is interesting because it doesn't need actual templates. You write very little code and Grails actual creates the pages and linkage for you... Grails will even create the dynamic db tables and do all the updates/deletes for you!


    Goals
        1. create a new grails app
        2. learn to use dynamic scaffolding
        3. use environments
        4. set up a mysql db
        5. connect to the mysql db
        6. run app in prod mode.

1. Create a new grails app

    Easy: grails create-app [name]
   

2. Dynamic Scaffolding

    A. First Create the Domain Class
        grails create-domain-class com.blog.Post
    B. Next Create the Scaffold controller
        grails create-scaffold-controller com.blog.Post

3. Environments

    By default we run the app in "dev" which uses H2 memory db.
    We can run other db's per environment, or have env. settings.
    For example, we can set up MYSQL for "prod" and leave H2 for dev
    To run with a spec env you do a grails prod run-app

4. Set up a MYSQL db

    First make sure MYSQL server is running
    In the MYSQL Workbench, create a new connection if you like
    Then create a new Schema - this is your db name.

5. Connect to the MYSQL db

    Back in Grails, open the file:
        /grails-app/conf/BuildConfig.groovy
        and uncomment:
        runtime 'mysql:mysql-connector-java:5.1.22'
    Next open the file:
        /grails-app/conf/DataSource.groovy
        update the url to be your msql server...
        ie "jdbc:mysql://localhost/blog"
        add
            username = [your mysql user]
        add
            password = [your mysql pass]

6. Run the App In Prod mode

    grails prod run-app

You can monitor the db you created, and watch as you
    create
    edit
    delete
via the app, the db will reflect the changes.

SIPP Simultaneous Jobs

The question came up today, about tshark... specifically if tshark/wireshark is smart enough to know which SIPP call is being captured in the media.

By default, no. 

However, you can get around this to run simultaneous jobs if you design your architecture to make use of Virtual Machines.  In my case, I have 5 Virtual Machines.  Each one runs a set of SIPP tests on a hourly schedule. 

If the SIPP tests run on top of each other (one call to phone number X and another to phone number Y), tcast will get a packet capture of both media streams... but it won't know which stream goes to whom.  So if stream #1 fails and stream #2 passes... it won't know what test to pass.

Virtual Machines

I get around this limitation by using Virtual Machines:
I set up the schedule so that Virtual Machine #1, handles Outbound tests only, with specific carriers.  I need each test to run every hour, so I have the ability to run about 6 tests... each sep. by 10min. 

For my purposes, if a test fails I retry it.  So... Test #1 runs, fails, it retries in 2min. I retry up to 3 times. This gets me 8-10 min worth of testing.  So I'm limited to 6 tests I can run per hour.

So for my design, I have Virtual Machine #1 that runs 6 outbound tests an hour.  Virtual Machine #2 runs 6 inbound tests an hour... and so forth.  This way they can overlap.

Each virtual machine has it's own Jenkins, driving it's own jobs (their own packet capture and sipp call.) 

Cloning

The easiest way to do this, is get one Virtual Machine all set up with Jenkins.  Once you have it working really well, clone it to multiple other VM's and change the jobs on each Jenkins of each VM.

SIPP & Jenkins Details

Per request, I'm adding some detail on the use of Jenkins and how I configured it to run the jobs and retain the details.

Why Jenkins?

First, why did I use Jenkins? Several reasons:

1. Jenkins is a build process, so by having the tests in Jenkins, I can kick off tests when a different job finishes building... i.e. developers push a new version of call control, and that starts the tests running
2. Jenkins allows me to retain historical data easily
3. Jenkins is push button, so anyone can come along and run the job.

Jekins Set Up with SIPP

Regarding my set up, from a high level, I needed Jenkins to kick off two simultaneous jobs... one is Running the SIPP load, and the other is capturing a PCAP during the test.  The PCAP capture may not be necessary for your tests... But if you do want it, you'll need to run the jobs simultaneously.

Simultaneous Jobs

In Jenkins I use the Multi Job plugin: https://wiki.jenkins-ci.org/display/JENKINS/Multijob+Plugin 

You then create a new project/job and set it up as a Multi-Job. On the job details, you  add a build option for a Multi Job Phase.  Then you can add multiple jobs to one phase.

This lets Jenkins run multiple jobs simultaneously.

Why not just have the parent job call the child jobs like job1, job2, etc.? 

the answer is due to collecting pass/fail criteria.  If you just have a Jenkins job kick off other jobs, the parent job will always pass, even if the children fail. 

The MultiJob Plugin will fail the parent job, if the children jobs fail.

Jenkins Running Sipp

To run the SIPP command I have a Jenkins job just for that.  In the Job details, under "Build Environment" I check "Execute Shell Script on Remote Host using SSH" (I believe this is avail with the SSH plugin.)  NOTE: You must define your SSH host and login on the main Jenkins configuration.
In the Execute Shell Script text box, I add:
cd /sipp-3.3
sudo sipp -s [Phone number] [Proxy] -sf /uac_pcap_g711.xml -m 2000 -mi [Proxy media IP] -d 1200 -trace_rtt -trace_err -stat_delimiter ,

That's it.  Now when this job is run, it will cd to the sipp folder, then run the sudo of sipp to call the number using our specific IP for the proxy. 

Packet Capture

In the packet capture job, I do the same thing as the SIPP job, I check off "Execute Shell Script..." but I point to a script I've made... like pcap.sh on the file structure.  In that file, I have a call to run tshark for X seconds and Output the pcap file to a specific folder.

That's it.

Then back to the MultiJob parent, it points to these two jobs, as one part of one phase.

Grails - Creating an Auto Dialer

I had a need for an internal tool where I work.

The premise is that our company buys and stores various numbers that they lease out later.  However, if those numbers do not have activity in a certain amount of time, they can become deactivated.

In the past, the company had individuals who would (every few months) get a list of current numbers in the risk zone for deactivation (hundreds of numbers) and dial each one to make sure it still went to our menu. 

So the Provisioning Team reached out to me to ask me if this could be automated....

They're requirements were that:
    a) they have lists of phone numbers (DNIS) that need to be called. this list could be a CSV
    b) they would like to upload it to a tool which would dial each number validating if it was active or not
    c) they would be notified of the results somehow.

I put together this tool and here's how I did it...

Basically I built an auto dialer with Grails and SIPCLI.  I could have used SIPP, but since I foresaw a future need to do text to speech, I opted for sipcli.  The downside to sipcli is that it is a windows tool... so you're tied to the Windows Env in this case.  But you could easily repurpose the methodology here to work with Linux using SIPP instead.

Using Grails, I created an application with:
grails create-app dialer
then I cd'd into the dialer directory and created the main controller:
grails create-controller csvImport
Once done I opened up my IDE and imported the Grails project (I use Grails Tools Suite.)

View

In the View I did this to capture the user's CSV file:
        <div id="status" role="complementary">
            <h1>Upload your CSV file of phone numbers</h1>
            <g:form controller="CsvImport" method="post" action="save"
                enctype ="multipart/form-data">
                   E-mail Results to a @mydomain.com address:<br>
                <g:textField type="field" name="emailAdd" value="brian@mydomain.com" style='width: 500px;' required=""/><p/>
                <input type="file" name="myfile" required/>
                <g:actionSubmit value="Start Process" action="save"/>
            </g:form>
        </div>

The controller looks like this:
   def save() {
        def emailTo = params.emailAdd
           if (emailTo =~ /@mydomain.com/) {
        def csv = request.getFile('myfile').inputStream.text
       
        def data = parseCsv(csv)
        runAsync{
            for(line in data) {
            println "Trying... $line.Phone"
            def dialNum = "sipcli/sipcli.exe $line.Phone -d **.**.*.*** [masked IP of our proxy] -o 4 -t \"This is a test. this is a test. this is a test. this is a test\"-l 3".execute()
            def outFile = new File("grails-app/test.txt")
            if (dialNum.text =~ /success/){               
                outFile << ("PASS on number $line.Phone\r\n")

            } else {
                System.getProperty("line.separator")
                outFile.append("FAIL on number $line.Phone\r\n")

            }
            }
 
            sendMail {
                multipart true
                to "${emailTo}"
                from "SOMEONE@ADDRESS.COM"
                subject "Provisioning Report"
                body 'Please find the attached Provisioning Report...'
                attachBytes 'grails-app/test.txt','text/csv', new File('grails-app/test.txt').readBytes()
            }
} else {
   render "Error: Email does not conform to @mydomain.com" }
            }
           
         }

To explain how it works...
The view is pretty easy to understand, it just takes a file and passes it to the controller.

Controller

The controller isn't doing any special validation, since this is a internal tool.  It takes the CSV and expects to have a column header called "Phone."  Phone will have a list of DNIS (or numbers) that need to be called.

CSV Parsing

To parse the CSV I import:
@Grab('com.xlson.groovycsv:groovycsv:1.0')
import static com.xlson.groovycsv.CsvParser.parseCsv
Then use this call def csv = request.getFile('myfile').inputStream.text to grab the input and finally pass it to the parser:
def data = parseCsv(csv)

Running Asynchronously

I don't want the  user to wait 30min for 500 phone numbers to be dialed... so instead, I send them immediately to a  page... this is handled with runAsync... this is a plugin called executor.  The Grails Executor plugin will run a closure asynchronously so you can do other stuff while the longer method runs.

Inside the runAsync closure is this for loop and if statement:
            for(line in data) {
            println "Trying... $line.Phone"
            def dialNum = "sipcli/sipcli.exe $line.Phone -d **.**.*.*** [masked IP of our proxy] -o 4 -t \"This is a test. this is a test. this is a test. this is a test\"-l 3".execute()
            def outFile = new File("grails-app/test.txt")
            if (dialNum.text =~ /success/){               
                outFile << ("PASS on number $line.Phone\r\n")
               
               
            } else {
                System.getProperty("line.separator")
                outFile.append("FAIL on number $line.Phone\r\n")

            }

Basically it's doing this:

For each line in the csv file, it prints out the phone number it's trying, and then I've defined an action to run the sipcli sip client.... to call that same number.  SipCli is a awesome command line sip tool for windows that can be used to find sip problems and issues.  It's very light and easy to use.  In this case I have it set to a 4 second timeout and i'm telling it to read the text, "This is a test..." when it makes the phone connection.

Assertions

The assertion of whether or not the phone call is valid is via the regex i'm doing in the if statement... If dialNum.text has success then we output to a file "Pass on number [DNIS]"
However, if the number fails to connect, we append to the same file "FAIL on number [DNIS]"

E-Mail

Finally, at the end, outside the runAsync closure, I do a call to email the results (that flat file) to a recipient, using the Grails mail plugin.  I'm passing the To value from the form... and as you may have seen, I'm forcing the tool to only work if an internal email is passed through.  The domain "mydomain.com" is a filler for the real domain I check. Since the tool uses an internal SMTP server, we can't send to outside emails... so I dont want the user to violate the SMTP capabilities.  Their email address entered (if from the right domain) is added to the To line below:
             sendMail {
                multipart true
                to "${emailTo}"
                from "SOMEONE@ADDRESS.COM"
                subject "Provisioning Report"
                body 'Please find the attached Provisioning Report...'
                attachBytes 'grails-app/test.txt','text/csv', new File('grails-app/test.txt').readBytes()
            }

That's it.  

Grails Project: Using Grails as a UI Wrapper to a CLI like SIPP

For many people this project is going to be Easy.  It's very simple.

The idea for this came from a situation at work.

I am a sole user of a command line SIP/VOIP tool called SIPP.  The tool is incredibly complex. It took me many weeks to get it up and running, but I know it well now and use it often. 

However, other members of the team could also benefit form the use of the tool, but some members of the office may not have a computer background, or SSH access to run the command line tool itself.

You may have command line tools you'd like to offload to others, but don't want them to make mistakes... so maybe using a GUI to wrap up the commands and constrain the options is useful for you as well.

To that end, I came up with an idea to play with a bit of Grails and get a Web Application stood up, that would power the command line tool itself.

The Setup (I wont cover these aspects):

First, in my case the tool (SIPP) needs to be installed
Second, Grails needs to be installed on the same environment

What I'll cover:

Building the Grails app
Making the calls to run the command line tool
Making the calls run in the background using Executor
Daemonize the app so it can run/stop and start on restart.

Pulling in server stats via Cacti will be covered in a different post.

Building the Grails app

This is pretty simple. There's not much difficulty in this task. 
So first things first... we need to know the command line tool parameters.  In my case I'm using SIPP.  The most common parameters I use are:
sipp -s [DNIS] [PROXY] -r [CALLS PER SECOND] -m [MAX CALLS] -sf [SCENARIO FILE] -d [DELAY OF THE CALL]

So I'll need to make a application that has a form with user selects for those items.  The PROXY in my case is going to be hard coded, as I don't want people accidentally sending traffic to the wrong IP/Host. 

In my case I only foresaw the need for one controller and a couple Views.  If you're not familiar with MVC, you might want to read up on it a bit.  Basically the Controller will handle logic, the View will be the display/rendering aspect of the app and the Model is the data handling.

So I'm going to make a super easy app that has one controller, and some views.

So lets start:

1. Make the grails app.  Go to a folder of your choice, and type grails create-app  At the prompt for a name, give it a name and hit enter.
2. It will now make a folder with the name of the Grails App that you just created.  Go ahead and enter the folder - cd [APP NAME]
3. In the app folder create a controller with the command grails create-controller At the prompt for a name, give it a name and hit enter.

Let's launch an IDE to edit this... I  use Spring's Grails Tool Suite.  I love Intellij, but the community (free) edition doesn't currently support Grails.  Only the paid ($500+) version does.

Import the project you just made.  In Grails Tool Suite it's File / Import / Project - Grails.

Once imported, lets edit the controller.

In the Project Tree in your IDE you'll see [web-app name]/controllers/[project-name]/[your-controller]

Go ahead and open that up in the IDE.

You'll have some code with a index action like
class SippcallController {
     def index() {
                    }
  }

I made a action that was more useful for what I'm doing.  So I have:
def callLogic() {
    def sipp = "sipp -s 18008888888 10.98.1.1 -r 1 -m 1 -sf uac.xml -d 1200".execute()
  }

Initially I just put in the actual command to dial a number via SIPP.  Then I tested it... it worked... so at that point I replaced all the parameters with values that will be coming from a user Form.  So the action became:

def callLogic() {
    def sipp = "sipp -s ${params.phoneNumber} 10.98.1.1 -r $(params.Rate} -m ${params.Max} -sf ${params.scenario} -d ${params.delay}".execute()

[view_darta:sipp.text]
  }

That last bit, [view_data:sipp} is a model I can access in a View or web page.  In a webpage of this app, I can just have ${view_data} and it will reference the output of the SIPP sip call itself.

Creating the Web Form for User Input

Now lets go ahead and edit the index.gsp file.  It's listed in the Project Explorer as: Project Name / Views /

Once that's open, you'll notice the basic sample page that Grails creates with each new application.  I removed all the Grails code within the Body Tags and replaced it with a form.... using g tags.

My form is like this ( the Grails tags are highlighted in green):
        <g:form name="callForm" controller="makeCall" action="callLogic">
        <p><h3>Phone number:</h3></p>
        <g:select name="phoneNumber" from = "${['12132830920', '12132830912', '12132830591', '13237549121'] }" value="12132830920" noSelection="['':'-Choose the phone number -']"/>
        <p><h3>Calls Per Second:</h3></p>
        <g:select name="cps" from="${1..30}" value="1"/>
        <p><h3>Max Calls:</h3></p>
        <g:select name="maxCount" from="${['1', '10', '50', '100', '500', '1000', '2000']}" value="1"/>
        <p><h3>How Long to Hold Audio Open (ms):</h3></p>
        <g:select name="delay" from="${['1200', '5000', '10000', '20000', '60000', '120000']}" value="1000"/>
          <p><h3>Scenario:</h3> </p>
          <g:select name="scenario" from ="${['uac.xml', 'codec_speex.xml', 'codec_g729.xml', 'carrier_sprint.xml'] }"
            value = "uac.xml" />
        <g:actionSubmit value="Place Call" action="callLogic"/>
        </g:form>

It's pretty easily readable. A few things to note:

• To handle multiple selections in a dropdown, you can use a function or just list them out like I did here.  A function is superior, but this was quick and easy to set up a test.  you make the g tag a select and you add from with "${['value1', 'value2']}" and so forth.  
• Like a regular form, you can set the default value with value="value1"  
• Make sure the form references your controller and action correctly.

 If done right, this should send the field data to your Controller and Action correctly... which would run the command line with the parameters supplied via this form. 

Creating an Output View

 

In my case I decided to make another page that would handle the output form the controller.  It's the same name as the controller.  So in the [project]/views/[subfolder]/callLogic.gsp page I will put some data from the SIPP tool....

I could add ${view_data}, and it would display the output from the SIPP test into the page itself.

In my case, as you can see in the screenshot, I'm pulling in server stats via Cacti.  It's too much to go into in this blog post, but I set up Cacti on the linux VM here that I'm using, to pull snmp data from the box I'm driving the SIPP load to.

When I first did this, the page loaded fine, but it would wait for SIPP to finish, then output the data to the view.

I now send the call to a background job using the Executor plugin for grails, and using the runAsync closure around the SIPP call in the controller.  This way once a user submits the form they load on the results page.  The data is still being collected and will need to be updated later onto the page (I haven't worked that part out yet.)

Installing Executor (to run background jobs)

In case you need this, here's how it works... you do a grails install-plugin executor
After it installs, you can then see the plugin listed in your IDE's project tree like so: project/plugins.  You can now use the methods the plugin gives access to.

In my case, I just wanted the runAsync method.  so back in my controller I added it like this:

def callLogic() {
    def sipp = "sipp -s ${params.phoneNumber} 10.98.1.1 -r $(params.Rate} -m ${params.Max} -sf ${params.scenario} -d ${params.delay}".execute()

runAsync{
[view_darta:sipp.text]
}
  }

This allows the output to be collected in the background. 

The part I haven't worked out yet, is getting a push or polling mechanism set up to get that data once it's ready.

Daemonizing It
I wanted to be able to start and stop this thing, so I set up a job in the /etc/init.d/ folder and called it sippgui  in that file is a series of commands, such as:

start() {
        cd /sippcall
        /sippcall/grails run-app -Dserver.port=8090 &
        sudo touch /var/lock/subsys/sippgui
        echo

}

You'll want to do something similar to stop it.

At that point it can be added to cron, or run manually with /etc/init.d/sippgui start|stop|restart, etc.

Btw. the -Dserver.port=8090 is how i'm setting the port it's using. 

Opening the Port

That's it... Oh WAIT one more thing...

If you can't get this App to load, you may need to open your firewall to allow traffic to this port (i.e. 8090.)  In my case I couldn't  use 8080, so I used a non standard port. I had to modify the IPTABLES to allow this. 

CENTOS uses IPTABLES so that's my solution. I won't go into details on it, just know that you'll need to open any non standard port and may need to google how to do that on whatever OS you're using. 

Setting up Raspberry Pi

This is a departure from the main crux of this blog.  But I wanted to gather some notes on my pitfalls I encountered with setting up a Raspberry Pi device.

Hardware and SD Card Set Up

I had the version 2 B 512 version of the Pi.
I used a PNY 16GB class 6 SD card
I used a solar/electric battery to power it
I used a usb keyboard
and a standard hdmi cable

I started this all off by downloading the official Raspberry "wheezy" distro (2013-05-25-wheezy-raspbian) from the direct download link.  However, I couldn't unzip it on windows... although the download was the correct size, windows' default unarcher gave me a "can't read" this file error.  However, 7zip would read it and uncompress it... I figured this was just a problem with Windows.

Butut when I used the img file that it produced to drop on the SD card... it corrupted the SD card.

Again - this was the direct download official link of the "wheezy" distro.  

At this point he SD card would read "18mb left of 56mb" yet this was a 16Gig card.  I freaked out a bit thinking the card was now damaged.  However I read that it only needs to be reformatted....

I tried to reformat using Windows' reformat tool (right click / format)... but the card would always read "56mb avail."

I in fact had to now download the official SD formatter... ugh.  Ok, Now that got me back to 16gigs.

I tried multiple downloads from that direct download link - all with the same problem!

Then I tried the torrent.

They recommend the torrent, but I hate using torrents.  I always end up with spyware from the torrent clients... anyway, I installed bit torrent and downloaded the distro via the torrent, and then uninstalled bit torrent afterwards.

I did get the torrent to download, it was about 10x faster then the direct link.  I also was able to unzip it fine without the error's encountered from the direct link.

I put the SD card back in the Pi, and plugged it back in... It booted up great.

Configuration

When it boots up successfully you'll see something resembling the old PC Bios menu.  This is how you'll configure your Raspberry Pi.

At the configuration screen, you'll want to:
1. set the thing to use the entire space on the SD card, it's the first option in this boot menu.
2. after that, if you want to boot to a desktop, go to that option, if you use a console only, skip it.
3. To turn on SSH (so you can remote into the box via SSH) you need to go to advanced settings and then choose SSH and then Enable.
4. If this is a public facing device, you might want to change the password as well - it's a option on the boot menu.
5. I also changed the hostname (it defaults to 'raspberrypi')

After that I chose to finish and reboot.

From here on out, you'll log in as your user "pi" with the password you picked... or use the default (raspberry.)

SSH

To SSH to this box, first get it's IP by running ifconfig from the command line.  You'll see "eth0" and in there a line inet addr:.  take that address.

From another box, using either terminal on mac, or Putty/supper putty on PC, you can just ssh over to:
ssh [ip]
login as user pi and input your pass.

Installing Software from the Command Line

If you're used to installers in Linux (like Centos' YUM) then you'll get the same thing here, but it's apt-get.  You'll sudo each command like this.  So: sudo apt-get iw tshark would install iw and tshark (for packet sniffing.)

Find the tools you want and they should give you the proper apt-get install commands.

Shutting Down the Raspberry Pi

Also another important thing.  The official site for Raspberry Pi, says to shut it down you just "unplug it" from what I've read this could damage the SD card.  So... you must run an official shutdown:

sudo shutdown -h now

From the UI, you click the red icon and choose shutdown.  Wait for the proper screen statement "system halted," and then remove the power cable.