PowerMTA is a high performance SMTP server used by many email marketing technology companies.  Not only does the server handle high volume of outgoing email, the server also provides various means of integration for email submission, data merging, and monitoring.

The server provides a monitoring interface over HTTP.  Server administrators can log into a web interface to see the current activity on the server.  This web interface can also send information marked up as XML.  Having integrated PowerMTA into various projects, Mass Transmit has built some PHP classes to assist with integrating with the monitoring interface.

PowerMTA configuration

You must enable the HTTP management interface and authorize the IPs to connect to it. Please refer to the PowerMTA™ v4.0 User’s Guide.

PowerMTA class

For detailed information on the data provided by the monitoring interface, please consult the PowerMTA™ v4.0 User’s Guide.

setOption(array|string $option, int|string $value = null) : null

Set a specific option prior to retrieving data.  Multiple name/value pairs can be specified by passing an associative array or repeated calling this method.  Many methods which retrieve data can be passed options as an associative array.

status() : string

Retrieves the status data in XML format.

queues(array $options = null) : string

Retrieves the queues data in XML format.  You can set the following options as an associative array of arguments or by calling the setOption() array.

• queue: [string] wildcard search. format: domain/queue
• sort: [string] field to sort by (name|rcpt|size)
• connected: [string] connected? (yes|no|both)
• paused: [string] paused? (yes|no|both)
• mode: [string] mode (normal|backoff|both)
• maxItems: [int] maximum number of items to display
• refresh: [int] n/a

queueDetail(string $queue) : string

Retrieves data for a specific queue in XML format.  $queue is specified as domain/queue.

domains(array $options = null) : string

Retrieves the domains data in XML format.

• domain: [string] wildcard search for domain
• vmta: [string] widcard search for virtual MTA
• sort: [string] field to sort by (name|rcpt|size)
• connected: [string] connected? (yes|no|both)
• maxItems: [int] maximum number of items to display
• refresh: [int] n/a

domainDetail(string $domain) : string

Retrieves data for a specific domain in XML format.

vmtas() : string

Retrieves data for the virtual MTAs in XML format.

jobs() : string

Retrieves data for the jobs in XML format.

logs() : string

Retrieves data for the log files in XML format.

getFile($file) : string|boolean

Retrieve the specified log file.  If $file is an accounting CSV file, it is passed to the Parse_Csv object for parsing.

getCsv() : Parse_Csv

Get the Parse_Csv object parsing the downloaded accounting log file.

deleteFile() : null

Delete the file on the localhost that was retrieved using getFile().

Parse_Csv class

There is an instance of the Parse_Csv object contained within the PowerMta object to parse any downloaded accounting log files.  After successfully calling PowerMta::getFile() to download an accounting, the file is passed to the Parse_Csv object for parsing.  When parsing a CSV file,the object will pass an array containing the values of the cells of any line matching the filter settings to a specified callback function.

setLineCallback(array|string $callback) : void

Specify a callback function (string) or an object’s  method (array) to pass the row from the CSV file matching the filter criteria.  The callback function will receive an array which is the fields of the row in order, left to right.

addFilter($key, $value) : void

Add a filter for the parser.  Rows matching the filters will be sent to the callback function/method as an array.  $key is either the numeric index for that columns or its ame from the header row.  $value is either an exact match or a regular expression (delimited by /../).  If $value is an array, the values will be OR’d for that key.  Multiple $key criteria will be AND’d together.  Multiple calls to addFilter() for the same will will also be AND’d together.  Specifying $key as * will apply that $value to all the fields.

parse() : array

Begin parsing the CSV file.

Examples

Get a list of .co.uk domains the PowerMTA server is connected to

$powermtaObj = new PowerMta();
$powermtaObj->setHost('powermta.domain');
$xml = $powermtaObj->domains(array('domain' => '*.co.uk', 'connected' => 'yes'));
$xmlObj = new SimpleXMLElement($xml);

Download and parse an accounting file for aol.com bounce records

$powermtaObj = new PowerMta();
$powermtaObj->setHost('powermta.domain');
$powermtaObj->getFile('/var/log/pmta/acct-2012-01-01-0000.csv');
$powermtaObj->getCsv()->addFilter('type', 'b');
$powermtaObj->getCsv()->addFilter('rcpt', '/aol.com$/');
$powermtaObj->getCsv()->setLineCallback('csvCallback');
$powermtaObj->getCsv()->parse();
$powermtaObj->deleteFile();
function csvCallback($lineArray) {
    print_r($lineArray);
}

Download

Download PowerMta PHP class files v. 0.9

Integrate with Port25′s PowerMTA SMTP Server’s Monitoring Interface Via HTTP is a post from the Mass Transmit Broadcast Blog. Subscribe to receive blog posts via email. Connect with us on Facebook, Twitter and Google+!

It is possible, however, for anyone to save the PDF from the browser. You can right-click or ctrl-click on the link to the PDF and save the file to the local computer. If the PDF is already displayed in the browser, a Save As… menu option will allow you to save it locally as well.

To force the download of the PDF, or any other file, you need to send the content-disposition HTTP header. Most server-side programmers send content-disposition and location HTTP heades from their scripts. You can also configure Apache to send the content-disposition header for PDFs (or any other files).


<Files *.pdf>
ForceType application/pdf
Header set Content-Disposition attachment
</Files>


This can be placed in your <VirtualHost> configuration.

Trigger Save As… Window for PDF Download is a post from the Mass Transmit Broadcast Blog. Subscribe to receive blog posts via email. Connect with us on Facebook, Twitter and Google+!

“/wp-content/plugins/theme_swapper/”

This newly created directory will house the plugin file and the Wurfl library.

Download the latest WURFL library to your “theme_swapper” directory. In “/wurfl-php-xxx/examples/demo/inc/” you’ll find the “header-config.inc” file. This file sets your Wurfl environment by including the Wurfl application files and the “Resources” directory and instantiates
the Wurfl object. The other file to configure is the “wurfl-config.xml” file, located in “/wurfl-php-xxx/examples/resources/”. There is an option for cache/persistence in this xml file, this is important to set-up correctly so your queries to the library don’t tax server resources. I’ve had great results using the “file” option for persistence. There is a helpful getting started guide at the Wurfl site here.

header-inc.php file:

session_start();
//ini_set('display_errors', 'on');
//error_reporting(E_ALL);

define("WURFL_DIR", dirname(__FILE__)."/WURFL/");
define("RESOURCES_DIR", dirname(__FILE__)."/resources/");

require_once WURFL_DIR . 'Application.php';

$wurflConfigFile = RESOURCES_DIR . 'wurfl-config.xml';
// Create WURFL Configuration from an XML config file
$wurflConfig = new WURFL_Configuration_XmlConfig($wurflConfigFile);
// Create a WURFL Manager Factory from the WURFL Configuration
$wurflManagerFactory = new WURFL_WURFLManagerFactory($wurflConfig);
// Create a WURFL Manager ($wurflManager is a WURFL_WURFLManager object)
$wurflManager = $wurflManagerFactory->create();
// Get information on device

$device = $wurflManager->getDeviceForHttpRequest($_SERVER);
$_SESSION['wireless'] = $device->getCapability('is_wireless_device') ;

For our example I want to get the value of “is_wireless_device” from the library and pass it to the
plugin filter function. For persistence I am storing the result in the $_SESSION['wireless'] variable.

For the plugin, inside of the “/theme_swapper/” directory create a new PHP file, give this file the same name
of the directory. The complete path should be: “/wp-content/plugins/theme_swapper/theme_swapper.php”. At the
top of this file will need to go the plugin specific meta-data.

Next, include the above mentioned “header-config.inc”.

Now come the actual plugin functions. In this case we are going to pass to the plugin the
result of our Wurfl query stored in the $_SESSION['wireless'] variable to filter values from
the WordPress wp_options table in the Database. WordPress plugin documentation can be found here.

/*** Include the WURFL library ***/
require_once 'header-config.inc';

//The three system values we want to filter
add_filter('template', array('wpThemeLoad','mobile_theme_loader'));
add_filter('option_template', array('wpThemeLoad','mobile_theme_loader'));
add_filter('option_stylesheet', array('wpThemeLoad','mobile_theme_loader'));

//Passes the value back to our filter functions
class wpThemeLoad {
	public function mobile_theme_loader() {
		$theme = getTheme::displaytheme();
			return $theme;
	}
}

/*This sets the theme we want, should be the actual name of the
* directory that houses your theme e.g. "/wp-content/themes/desktop_theme/"
*/
class getTheme {
	public static function displaytheme() {
		if($_SESSION['wireless'] == 'false') {
			return 'desktop_theme';
			} else {
			return 'mobile_theme';
		}
	}
}

?>

Lastly, login to your WordPress site and activte the “Theme Swapper” plugin.

Device Detection Plugin for WordPress is a post from the Mass Transmit Broadcast Blog. Subscribe to receive blog posts via email. Connect with us on Facebook, Twitter and Google+!


INSERT INTO [table] ([columns]) VALUES ([values])
ON DUPLICATE KEY UPDATE [column updates];


The Zend_Db_Table_Abstract class may be extended to incorporate a method to execute this statement. The Zend_Db classes are meant to be database agnostic, so this can only work if your database is MySQL. Since this SQL statement is a hybrid of INSERT and UPDATE, the method accepts two data arrays: one for insert and one for update. If the INSERT data encounters a duplicate key, the update array is executed on the existing row. The method will return whichever Zend_Db_Statement class you are using as the method utilizes the adapter’s query() method.

class MyProject_BaseTable extends Zend_Db_Table_Abstract
{
	/**
	 * Execute an INSERT ON DUPLICATE KEY statement
	 * @param array $insertData Data to use for INSERT portion
	 * @param array $updateData Data to use for UPDATE portion
	 * @return Zend_Db_Statement
	 */
	public function insertOnDuplicateKeyUpdate($insertData, $updateData) {
		// generate INSERT part statement
		$insertCols = '';
		$insertVals = '';
		foreach($insertData as $column => $value) {
			$insertCols .= $this->getAdapter()->quoteIdentifier($column) . ',';
			$insertVals .=	(get_class($value) == 'Zend_Db_Expr')
						? $value->__toString()
						: $this->getAdapter()->quoteInto('?', $value);
			$insertVals .= ',';
		}
		$insertCols = rtrim($insertCols, ',');
		$insertVals = rtrim($insertVals, ',');

		// generate UPDATE part of statement
		$updateExpr = '';
		foreach($updateData as $column => $value) {
			$updateExpr .=	$this->getAdapter()->quoteIdentifier($column) . ' = ';
			$updateExpr .=	(get_class($value) == 'Zend_Db_Expr')
						? $value->__toString()
						: $this->getAdapter()->quoteInto('?', $value);
			$updateExpr .= ',';
		}
		$updateExpr = rtrim($updateExpr, ',');

		// generate statement
		$sql = 'INSERT INTO ' . $this->_name . ' (' . $insertCols . ') VALUES (' . $insertVals . ') ';
		$sql .= 'ON DUPLICATE KEY UPDATE ' . $updateExpr . ';';

		return $this->_db->query($sql);
	}
}

Incorporate Insert On Duplicate Key Update Method in Zend_Db_Table is a post from the Mass Transmit Broadcast Blog. Subscribe to receive blog posts via email. Connect with us on Facebook, Twitter and Google+!

The Zend_Db classes are meant to be database agnostic, though MySQL is largely the underlying database in Zend projects. The Zend_Db_Table class is without a replace() method as it is only supported by MySQL. You can, however, add a replace() method to your table classes by extending Zend_Db_Table_Abstract and extending your table classes from this child class of Zend_Db_Table_Abstract.

class MyProject_BaseTable extends Zend_Db_Table_Abstract
{
	/**
	 * Replace function to execute a MySQL REPLACE.
	 * @param array $data data array just as if it was for insert()
	 * @return Zend_Db_Statement_Mysqli
	 */
	public function replace($data) {
		// get the columns for the table
		$tableInfo = $this->info();
		$tableColumns = $tableInfo['cols'];

		// columns submitted for insert
		$dataColumns = array_keys($data);

		// intersection of table and insert cols
		$valueColumns = array_intersect($tableColumns, $dataColumns);
		sort($valueColumns);

		// generate SQL statement
		$cols = '';
		$vals = '';
		foreach($valueColumns as $col) {
			$cols .= $this->getAdapter()->quoteIdentifier($col) . ',';
			$vals .=	(get_class($data[$col]) == 'Zend_Db_Expr')
						? $data[$col]->__toString()
						: $this->getAdapter()->quoteInto('?', $data[$col]);
			$vals .= ',';
		}
		$cols = rtrim($cols, ',');
		$vals = rtrim($vals, ',');
		$sql = 'REPLACE INTO ' . $this->_name . ' (' . $cols . ') VALUES (' . $vals . ');';

		return $this->_db->query($sql);

	}
}

Extend Zend_Db_Table with Replace() Method is a post from the Mass Transmit Broadcast Blog. Subscribe to receive blog posts via email. Connect with us on Facebook, Twitter and Google+!

Under Apache, you may turn off PHP execution on a per-directory basis. In the VirtualHost directive, add:

<Directory /full/path/to/directory>
php_flag engine off
</Directory>

If you’re allowed to use .htaccess files, create a .htaccess file in the directory you wish to disable PHP execution:

php_flag engine off

Disable PHP Execution in Certain Directories is a post from the Mass Transmit Broadcast Blog. Subscribe to receive blog posts via email. Connect with us on Facebook, Twitter and Google+!

An SMTP server receiving mail or spam prevention system can perform SPF checks using the FROM header of the email and the IP of the originating server. In the check, the domain or hostname part of the email in the FROM header is used for the DNS lookup. For instance, if the server receives an email from john.doe@some.domain.com, a TXT record lookup is performed on some.domain.com:

Using dig on Unix/Linux:

> dig -t txt some.domain.com
;; ANSWER SECTION:
some.domain.com. 4754 IN TXT "v=spf1 ip4:192.168.1.10 -all"


Using nslookup on Windows:

> nslookup
> set type=TXT
> some.domain.com
Non-authoritative answer:
some.domain.com text =
"v=spf1 ip4:192.168.1.10 -all"


Now the receiving server sees that only IP 192.168.1.10 is allowed to send emails for some.domain.com. If the sending server is not 192.168.1.10, then the SPF check has failed. The -all is a catchall for all IPs. The minus denotes a hard fail, hence the mail administrator for some.domain.com really does not want mail for that hostname originating from anywhere other than 192.168.1.10. A “~” denotes a soft fail. This directive is more lenient as it indicates some mail may originate from other IPs. Base on this hard/soft fail, a weight to the spam score may be applied. A hard fail will have a heavier score if not outright rejection of the email.

As an email marketer, publishing an SPF record for your sending domain/hostname will improve your deliverability. The “harder” the fail, the more secure the receiving SMTP servers will regard your email infrastructure to be.

More information regarding SPF can be found at http://www.openspf.org including SPF record syntax and links to SPF testing tools. Clients using our EmailTransmit email marketing service should include:spf.emailtransmit.com to the SPF record of all domains/hostnames used in the FROM email for their campaigns.

Publish SPF Record to Increase Email Deliverability is a post from the Mass Transmit Broadcast Blog. Subscribe to receive blog posts via email. Connect with us on Facebook, Twitter and Google+!

If you look at the standard Zend Framework file hierarchy, your controllers reside in “/application->controllers”, and ideally your custom class files reside in “/library->”. To enable all your controllers to communicate with your library files, simply edit your application.ini file like so:

1) Make sure you have your library added to your “includePaths”

includePaths.library = APPLICATION_PATH "/../library"

2) Add this line:

autoloaderNamespaces.Example = Example_

Where “Example” is the Namespace you want to specify.

So now you have the Namespace set-up correctly, how do you use it?

One level directly below your “library” create a directory that echoes your newly created Namespace. e.g. “/library/Example”.

Inside the “Example” directory create a new PHP file named “Service.php”. The naming of your class in “Service.php” should follow the directory structure you have created, so the class name in this case will look like:

class Example_Service {

When trying to create the “Example_Service” object from one of your controllers, you can now call it directly:

public function indexAction()
    {
    $example = new Example_Service();
    //do something
    }

There is now no need to have multiple lines of include files to maintain.

Exclude the Include: Zend Framework Namespaces is a post from the Mass Transmit Broadcast Blog. Subscribe to receive blog posts via email. Connect with us on Facebook, Twitter and Google+!

• frequently connecting to the same set of servers from one location
• Allowing a cron job to remotely execute or transfer files to another server

The process to allow this is to generate a private/public key pair on the computer from which you will be connecting. You then place the public key on the remote server(s) to which you will be connecting. Here’s how:

Go to your SSH preferences directory on the client

Log into the computer from which you will be connecting. Log in as the user who will be initiating the ssh/scp/sftp client connection. In the case of a cron job, this may be root.

Go to that user’s ssh preferences directory. This is at ~/.ssh:
cd ~/.ssh

If that directory does not exist, create it:
mkdir ~/.ssh
cd ~/.ssh


Generate the private/public key pair

The best results I’ve had are with a DSA key pair:

ssh-keygen -t dsa

This will begin the process of generating the keys. Opt for no passphrase else you’ll be asked for it every time you try to connect (thus defeating the purpose of a password-less login).

Generating public/private dsa key pair.
Enter file in which to save the key (/home/jdoe/.ssh/id_dsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/jdoe/.ssh/id_dsa.
Your public key has been saved in /home/jdoe/.ssh/id_dsa.pub.
The key fingerprint is:
f1:44:74:5b:65:c9:af:92:9d:74:c5:0f:8e:4d:47:01 jdoe@domain.com


You now have two keys: id_dsa and id_dsa.pub. id_dsa is your private key and must remain on this server and kept secure. id_dsa.pub is the public key you will place on all servers to which you wish to connect.

Be sure only this user has permission to the private key:

chmod 700 ~/.ssh/id_dsa

Transfer the public key to the server(s) to which you want to connect

The public key, id_dsa.pub, goes into the authorized_keys files of the user on the remote server you will be connecting as. The easiest way this is accomplished is:

ssh remoteuser@remotedomain.com 'cat >> ~/.ssh/authorized_keys' < ~/.ssh/id_dsa.pub

This executes the cat command on the remote server which will take the contents of ~/.ssh/id_dsa.pub on the local server and append it to ~/.ssh/authorized_keys on the remote server for user remoteuser. You will be prompted for the password for remoteuser.

Try connecting

Now try connecting to the remote server:

ssh remoteuser@remotedomain.com

You should not have to enter a password. If you are still prompted for a password, there's some trouble shooting to be done. One thing to check is the correct name of the authorized_keys file on the remote server. This is found in the AuthorizedKeysFile setting in /etc/ssh/sshd_config on the remote server.

If you want to connect to other servers from the same location, place id_dsa.pub on those servers. There is no need to generate a new key pair.

SSH key authentication HOWTO is a post from the Mass Transmit Broadcast Blog. Subscribe to receive blog posts via email. Connect with us on Facebook, Twitter and Google+!

My choice for this is the cURL PHP extension. If you are using the Zend Framework there is a built in HTTP client – I still prefer to use the native cURL php library, partly because it handles
SSL requests (in Zend you need to use a cURL adapter to achieve this within their HTTP client*), but mostly because I can reuse the code for non-zend based projects with a minimum of fuss.

For example you may have a class file that is calling the YouTube Data API half a dozen times and then the Google Analytics API another x number of times. By writing new cURL code for each call you are going to end up with a very
bloated code file, and a time consuming one if a change comes down the pipe.

Some of these requests will be standard GET/POST requests sent over “http” whilst others will contain sensitive information such as an API key or token. Those particular requests will probably need to be sent over “https”, so essentially we have 4 types of cURL/API requests: ‘GET’ or ‘POST’ and ‘HTTP’ or ‘HTTPS’

To save yourself a lot of time and to make your code more manageable create a
cURL class containing a method for each type of request. Each time you need to make an API call simply reference the particular cURL method from the class file you created.

Example: Secure Post Request

Your cURL class file:

class curlrequest {
// $post_string in the form of:
// var1=xxx&var2=yyy&var3=zzz
public function curlHttpsPost($url, $post_string) {
$curl = curl_init();
$options = array(CURLOPT_URL => $url,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_POST => TRUE,
CURLOPT_POSTFIELDS => $post_string,
//these are the HTTPS related options
CURLOPT_SSL_VERIFYHOST => 0,
CURLOPT_SSL_VERIFYPEER => false,);
curl_setopt_array($curl, $options);
$response = curl_exec($curl);
curl_close($curl);
return $response ;
}
//Additional curl methods here
}

Your PHP code that calls the method:


$request = new curlrequest();
$call = $request->curlHttpsPost("https://some_API_entrypoint", "var1=xxx&var2=yyy");
//code to deal with the result of $call


So the call is made using your curl object in 2 lines of code.

Simplify Your Use of cURL is a post from the Mass Transmit Broadcast Blog. Subscribe to receive blog posts via email. Connect with us on Facebook, Twitter and Google+!