[zi-cvs] packages/com.zzoss.zis.lib ApplicationRepository.php,NONE,1.1 ApplicationXMLOutput.php,NONE,1.1 Config.php,NONE,1.1 DistributionRepository.php,NONE,1.1 DistributionXMLOutput.php,NONE,1.1 PackageRepository.php,NONE,1.1 PackageXMLOutput.php,NONE,1.1 package.xml,NONE,1.1

Update of /cvsroot/zzossinstaller/packages/com.zzoss.zis.lib
In directory sc8-pr-cvs1:/tmp/cvs-serv9308

Added Files:
	ApplicationRepository.php ApplicationXMLOutput.php Config.php 
	DistributionRepository.php DistributionXMLOutput.php 
	PackageRepository.php PackageXMLOutput.php package.xml 
Log Message:
initial release

--- NEW FILE: ApplicationRepository.php ---
<?php
/**
* This is a class for handling I/O functions
* for applications in the repository
*
* @package com.zzoss.installer.server.lib
* @version $Id: ApplicationRepository.php,v 1.1 2004/01/14 16:42:31 czonsius Exp $
* @author Christian Zonsius <[email protected]>
* @copyright 2001-2003 ZZOSS GbR, http://www.zzoss.com
* @license GPL
*/

require_once 'ZZOSS_Installer_Server/Config.php';
require_once 'ZZOSS_Installer_Server/ApplicationXMLOutput.php';
require_once 'ZZOSS_Installer_Server/DistributionRepository.php';

/**   
 * This class provides functions for the application
 * repository
 *   
 * @version  1   
 * @author   Christian Zonsius <[email protected]>; |    
 */   

class ZZOSS_ApplicationRepository
{

	var $connectors;

	function getApplication( $ddo )
	{
		// set criteria
		$criteria = array(
						'_ddo' => '= "'.$ddo.'"'
					 );
		// retrieve package
		$package = $this->connectors['retrieval']->call('getRecord', array( $criteria ) );
		return $package;
	}
	
	function getApplicationByID( $id )
	{
		// set criteria
		$criteria = array(
						'_id' => '= "'.$id.'"'
					 );
		// retrieve package
		$package = $this->connectors['retrieval']->call('getRecord', array( $criteria ) );
		return $package;
	}
	
	function getApplicationByName( $name )
	{
		// set criteria
		$criteria = array(
						'name' => '= "'.$name.'"'
					 );
		// retrieve application
		$package = $this->connectors['retrieval']->call('getRecord', array( $criteria ) );
		return $package;
	}

	function getApplicationByNameVersion( $name, $version )
	{
		// set criteria
		$criteria = array(
						'name' => '= "'.$name.'"',
						'version' => '= "'.$version.'"'
					);
		// retrieve application
		$package = $this->connectors['retrieval']->call('getRecord', array( $criteria ) );
		return $package;
	}
	
	function getApplicationXML( $ddo )
	{
		$application = $this->getApplication( $ddo );
		$xml = $this->application2XML( $application );
		return $xml;
	}
	
	function getApplicationByNameVersionXML( $name, $version )
	{
		$application = $this->getApplicationByNameVersion( $name, $version );
		$xml = $this->application2XML( $application );
		return $xml;
	}
	
	function listApplications( $distribution_ddo = null )
	{
		if($distribution_ddo != null)
		{
			$applications = array();
			$distributionRepository = new ZZOSS_DistributionRepository();
			$distribution = $distributionRepository->getDistribution( $distribution_ddo );
			if(is_array($distribution['application'])) {
				foreach($distribution['application'] as $item) {
					$application = $this->getApplicationByID( $item['id'] );
					array_push( $applications, $application );
				}
			}
		} else {
			$applications = $this->connectors['retrieval']->call('listRecords', array());
		}
		return $applications;
	}
	
	function listApplicationsXML( $distribution_ddo = null )
	{
		$applications = $this->listApplications( $distribution_ddo );
		$xml = $this->applications2XML( $applications );
		return $xml;
	}
	
	function application2XML( $item )
	{
		$xml = $this->output->application2XML( $item );
		return $xml;
	}
	
	function applications2XML( $item )
	{
		$xml = $this->output->applications2XML( $item );
		return $xml;
	}
	
	function removeApplication( $ddo )
	{
		// set criteria
		$criteria = array(
						'_ddo' => '= "'.$ddo.'"'
					 );
		// remove package
		$this->connectors['manipulation']->call('deleteRecord', array( $criteria ) );
		// TODO: unlink tgz / package xml from filesystem
		// TODO: unlink assignments in other applications
	}
	
	function importXML( $fileXML )
	{
		// check if file exists
		if(!file_exists($fileXML)) {
			return PEAR::raiseError('file "'.$fileXML.'" not found');
		}
		// create parser object
        $config = new ZZOSS_InstallerConfig(
			array('cache' => false, 'numeric' => array('maintainer','package','license','copyright'))
		);
        $config->setFile($fileXML);
        $xml = $config->query('/application');
		// add to database
		$item['name'] = $xml['name'];
		$item['summary'] = $xml['summary'];
		$item['description'] = $xml['description'];
		$item['homepage'] = $xml['homepage'];
		$item['version'] = $xml['release']['version'];
		$item['date'] = $xml['release']['date'];
		$item['state'] = $xml['release']['state'];
		$item['notes'] = $xml['release']['notes'];
		// build license array
		$item['license'] = array();
		if(is_array($xml['release']['license'])) {
			foreach($xml['release']['license'] as $license) {
				$subitem = array(
						'name' => $license['#'],
						'url' => $license['@']['url'],
						'version' => $license['@']['version']
				);
				array_push($item['license'], $subitem);
			}
		}
		// build maintainer array
		$item['maintainer'] = $xml['maintainers']['maintainer'];
		// build package package array
		$item['package'] = array();
		if(is_array($xml['release']['packages']['package'])) {
			foreach($xml['release']['packages']['package'] as $package) {
				$subitem = array(
						'id' => $package['@']['name'].'-'.$package['@']['version'],
						'baseinstalldir' => $package['@']['baseinstalldir'],
						'required' => (($package['@']['use'] == 'required') ? 1 : 0)
				);
				array_push($item['package'], $subitem);
			}
		}
		// add record
		$this->addApplication( $item );
		// debug
		// print_r($item);
	}
	
	function updateApplication( $item )
	{
		// update application
		$criteria = array('_ddo' => '= "'.$item['_ddo'].'"');
		$this->connectors['manipulation']->call( 'updateRecord', array( $item, $criteria ));
	}
	
	function addApplication( $item )
	{
		// add application
		$this->connectors['manipulation']->call( 'addRecord', array( $item ));
	}

	function ZZOSS_ApplicationRepository()
	{
		// get manipulation connector
		$this->connectors['manipulation'] = ZZOSS_Framework::connect('zzoss_application_repository/connector/manipulation');
		// get retrieval connector
		$this->connectors['retrieval'] = ZZOSS_Framework::connect('zzoss_application_repository/connector/retrieval');
		// get xml output object
		$this->output =& new ZZOSS_ApplicationXMLOutput();
	}

}

?>
--- NEW FILE: ApplicationXMLOutput.php ---
<?php
/**
* This is a class for handling I/O functions
* for distributions in the repository
*
* @package com.zzoss.zis.lib
* @version $Id: ApplicationXMLOutput.php,v 1.1 2004/01/14 16:42:31 czonsius Exp $
* @author Christian Zonsius <[email protected]>
* @copyright 2001-2003 ZZOSS GbR, http://www.zzoss.com
* @license GPL
*/

/**   
 * This class provides functions for XML export of
 * application
 *   
 * @version  1   
 * @author   Christian Zonsius <[email protected]>; |    
 */   
 
class ZZOSS_ApplicationXMLOutput {

	function _getXMLHeader()
	{
		$xml  = '<?xml version="1.0" encoding="ISO-8859-1" ?>'."\n";
		return $xml;
	}

	function _application2XML( $item )
	{
		$xml .= '<application version="1.0">'."\n";
		$xml .= '	<name>'.$item['name'].'</name>'."\n";
		$xml .= '	<summary>'.$item['summary'].'</summary>'."\n";
		$xml .= '	<description>'.$item['description'].'</description>'."\n";
		$xml .= '	<homepage>'.$item['homepage'].'</homepage>'."\n";
		if(is_array($item["maintainer"])) {
			$xml .= '	<maintainers>'."\n";
			foreach($item["maintainer"] as $maintainer) {
				$xml .= '		<maintainer>'."\n";
				$xml .= '			<user>'.$maintainer['user'].'</user>'."\n";
				$xml .= '			<name>'.$maintainer['name'].'</name>'."\n";
				$xml .= '			<email>'.$maintainer['email'].'</email>'."\n";
				$xml .= '			<role>'.$maintainer['role'].'</role>'."\n";
				$xml .= '		</maintainer>'."\n";
			}
			$xml .= '	</maintainers>'."\n";
		}
		$xml .= '	<release>'."\n";
		$xml .= '		<version>'.$item['version'].'</version>'."\n";
		$xml .= '		<date>'.$item['date'].'</date>'."\n";
		$xml .= '		<licenses>'."\n";
		if(is_array($item["license"])) {
			foreach($item["license"] as $license) {
				$xml .= '		<license url="'.$license['url'].'" version="'.$license['version'].'">'.$license['name'].'</license>'."\n";
			}
		}
		$xml .= '		</licenses>'."\n";
		$xml .= '		<state>'.$item['state'].'</state>'."\n";
		$xml .= '		<notes>'.$item['notes'].'</notes>'."\n";
		$xml .= '		<packages>'."\n";
		if(is_array($item['package'])) {
			foreach($item['package'] as $package) {
				$xml .= '			<package name="'.$package['id'].'" ';
				if($package['required'] == 1) {
					$xml .= 'use="required" ';
				}
				if(strlen($package['baseinstalldir'])>0) {
					$xml .= 'baseinstalldir="'.$package['baseinstalldir'].'" ';
				}
				$xml .= '/>'."\n";
			}
		}
		$xml .= '		</packages>'."\n";
		$xml .= '	</release>'."\n";
		$xml .= '</application>'."\n";
		return $xml;
	}
	function _applicationItem2XML( $item )
	{
		$xml .= '	<application>'."\n";
		$xml .= '		<name>'.$item['name'].'</name>'."\n";
		$xml .= '		<summary>'.$item['summary'].'</summary>'."\n";
		$xml .= '		<description>'.$item['description'].'</description>'."\n";
		$xml .= '		<homepage>'.$item['homepage'].'</homepage>'."\n";
		if(is_array($item["maintainer"])) {
			$xml .= '		<maintainers>'."\n";
			foreach($item["maintainer"] as $maintainer) {
				$xml .= '			<maintainer>'."\n";
				$xml .= '				<user>'.$maintainer['user'].'</user>'."\n";
				$xml .= '				<name>'.$maintainer['name'].'</name>'."\n";
				$xml .= '				<email>'.$maintainer['email'].'</email>'."\n";
				$xml .= '				<role>'.$maintainer['role'].'</role>'."\n";
				$xml .= '			</maintainer>'."\n";
			}
			$xml .= '		</maintainers>'."\n";
		}
		$xml .= '		<release>'."\n";
		$xml .= '			<version>'.$item['version'].'</version>'."\n";
		$xml .= '			<date>'.$item['date'].'</date>'."\n";
		$xml .= '			<licenses>'."\n";
		if(is_array($item["license"])) {
			foreach($item["license"] as $license) {
				$xml .= '			<license url="'.$license['url'].'" version="'.$license['version'].'">'.$license['name'].'</license>'."\n";
			}
		}
		$xml .= '			</licenses>'."\n";
		$xml .= '			<state>'.$item['state'].'</state>'."\n";
		$xml .= '			<notes>'.$item['notes'].'</notes>'."\n";
		$xml .= '		</release>'."\n";
		$xml .= '		<filelist>'."\n";
		$xml .= '			<descriptor role="application">'.ZZOSS_Framework::conf('zzoss_framework/paths/url').'get/application/'.$item['name'].'-'.$item['version'].'/application.xml</descriptor>'."\n";
		$xml .= '			<descriptor role="packages">'.ZZOSS_Framework::conf('zzoss_framework/paths/url').'get/application/'.$item['name'].'-'.$item['version'].'/packages.xml</descriptor>'."\n";
		$xml .= '		</filelist>'."\n";
		$xml .= '	</application>'."\n";
		return $xml;
	}
	
	function application2XML( $item )
	{
		$xml  = $this->_getXMLHeader();
		$xml .= $this->_application2XML( $item );
		return $xml;
	}

	function applications2XML( $items )
	{
		$xml  = $this->_getXMLHeader();
		$xml .= '<applications version="1.0">'."\n";
		if(is_array($items)) {
			foreach($items as $key => $item) {
				if(is_integer($key)) {
					$xml .= $this->_applicationItem2XML( $item );
				}
			}
		}
		$xml .= '</applications>';
		return $xml;
	}
}
?>
--- NEW FILE: Config.php ---
<?php  
    /*   
    Copyright (C) 2001-2003 ZZOSS GbR, http://www.zzoss.com
    ----------------------------------------------------------------------   
    This program is free software; you can redistribute it and/or   
    modify it under the terms of the GNU General Public License   
    as published by the Free Software Foundation; either version 2   
    of the License, or (at your option) any later version.   
    ----------------------------------------------------------------------   
    $Id: Config.php,v 1.1 2004/01/14 16:42:31 czonsius Exp $   
    */

require_once 'ZZOSS_Config/Config.php';

class ZZOSS_InstallerConfig extends ZZOSS_Config
{
    var $cache_dir;
    
    function ZZOSS_InstallerConfig($options = array())
    {
        $this->setOptions($options);
    }
    
    function setCacheDir($dir)
    {
        $this->cache_dir = $dir;
    }
    
    function setFile($file)
    {
        $this->file = $file;
    }
    
    function writeCacheUnique()
    {
        // compose the name of the cache file
        $tmpPath = $this->cache_dir;
        $parts = pathinfo($this->file);
        if(strlen($tmpPath)<1) {
            $tmpPath = $parts['dirname'].'/';
        } else {
            $cache_file_prefix = md5($parts['dirname']).'_';
        }
        $cache_file = $tmpPath.$cache_file_prefix.substr($parts['basename'],0,strrpos($parts['basename'],'.')).'.reg';
        return $this->writeCache($cache_file);
    }
}
?>
--- NEW FILE: DistributionRepository.php ---
<?php
/**
* This is a class for handling I/O functions
* for distributions in the repository
*
* @package com.zzoss.zis.lib
* @version $Id: DistributionRepository.php,v 1.1 2004/01/14 16:42:31 czonsius Exp $
* @author Christian Zonsius <[email protected]>
* @copyright 2001-2003 ZZOSS GbR, http://www.zzoss.com
* @license GPL
*/

require_once 'ZZOSS_Installer_Server/Config.php';
require_once 'ZZOSS_Installer_Server/DistributionXMLOutput.php';

/**   
 * This class provides functions for the distribution
 * repository
 *   
 * @version  1   
 * @author   Christian Zonsius <[email protected]>; |    
 */   
 
class ZZOSS_DistributionRepository {

	var $connectors;

	var $output;
	
	function getDistribution( $ddo )
	{
		// set criteria
		$criteria = array(
						'_ddo' => '= "'.$ddo.'"'
					 );
		// retrieve package
		$package = $this->connectors['retrieval']->call('getRecord', array( $criteria ) );
		return $package;
	}

	function getDistributionByID( $id )
	{
		// set criteria
		$criteria = array(
						'_id' => '= "'.$id.'"'
					 );
		// retrieve package
		$package = $this->connectors['retrieval']->call('getRecord', array( $criteria ) );
		return $package;
	}
	
	function getDistributionByName( $name )
	{
		// set criteria
		$criteria = array(
						'name' => '= "'.$name.'"'
					 );
		// retrieve package
		$package = $this->connectors['retrieval']->call('getRecord', array( $criteria ) );
		return $package;
	}

	function getDistributionByNameVersion( $name, $version )
	{
		// set criteria
		$criteria = array(
						'name' => '= "'.$name.'"',
						'version' => '= "'.$version.'"'
					 );
		// retrieve distribution
		$distribution = $this->connectors['retrieval']->call('getRecord', array( $criteria ) );
		return $distribution;
	}
	
	function getDistributionByNameVersionXML( $name, $version )
	{
		$array = $this->getDistributionByNameVersion( $name, $version );
		$xml = $this->distribution2XML( $array );
		return $xml;
	}
	
	function distribution2XML( $distribution )
	{
		$xml = $this->output->distribution2XML( $distribution );
		return $xml;
	}
	
	function distributions2XML( $distributions )
	{
		$xml = $this->output->distributions2XML( $distributions );
		return $xml;
	}
	
	function removeDistribution( $ddo )
	{
		// set criteria
		$criteria = array(
						'_ddo' => '= "'.$ddo.'"'
					 );
		// TODO: extend zzoss repository connector with deleteRecords method
		$this->connectors['manipulation']->call('deleteRecord', array( $criteria ) );
	}
	
	function addDistribution( $item )
	{
		$this->connectors['manipulation']->call( 'addRecord', array( $item ));
	}
	
	function importXML( $fileXML )
	{
		// check if file exists
		if(!file_exists($fileXML)) {
			return PEAR::raiseError('file "'.$fileXML.'" not found');
		}
		// create parser object
        $config = new ZZOSS_InstallerConfig(
			array('cache' => false, 'numeric' => array('file','descriptor'))
		);
        $config->setFile($fileXML);
        $xml = $config->query('/distribution');
		// add to database
		$item['name'] = $xml['name'];
		$item['summary'] = $xml['summary'];
		$item['description'] = $xml['description'];
		$item['homepage'] = $xml['homepage'];
		$item['version'] = $xml['release']['version'];
		$item['date'] = $xml['release']['date'];
		$item['state'] = $xml['release']['state'];
		$item['notes'] = $xml['release']['notes'];
		// TODO: build application array
		$item['application'] = array();
		// add distribution
		$this->addDistribution( $item );
		// debug
		print_r($item);

	}
	
	function listDistributions()
	{
		// get distributions
		$distributions = $this->connectors['retrieval']->call('listRecords', array());
		return $distributions;
	}
	
	function listDistributionsXML()
	{
		// get distributions
		$distributions = $this->listDistributions();
		$xml = $this->output->distributions2XML($distributions);
		return $xml;
	}
	
	function assignApplication( $ddo_distribution, $ddo_application )
	{
		// TODO
	}

	function unassignApplication( $ddo_distribution, $ddo_application )
	{
		// TODO
	}

	function ZZOSS_DistributionRepository()
	{
		// get manipulation connector
		$this->connectors['manipulation'] = ZZOSS_Framework::connect('zzoss_distribution_repository/connector/manipulation');
		// get retrieval connector
		$this->connectors['retrieval'] = ZZOSS_Framework::connect('zzoss_distribution_repository/connector/retrieval');
		// get xml output object
		$this->output =& new ZZOSS_DistributionXMLOutput();
	}

}

?>
--- NEW FILE: DistributionXMLOutput.php ---
<?php
/**
* This is a class for handling I/O functions
* for distributions in the repository
*
* @package com.zzoss.zis.lib
* @version $Id: DistributionXMLOutput.php,v 1.1 2004/01/14 16:42:31 czonsius Exp $
* @author Christian Zonsius <[email protected]>
* @copyright 2001-2003 ZZOSS GbR, http://www.zzoss.com
* @license GPL
*/

/**   
 * This class provides functions for XML export of
 * distributions
 *   
 * @version  1   
 * @author   Christian Zonsius <[email protected]>; |    
 */   
 
class ZZOSS_DistributionXMLOutput {

	function _getXMLHeader()
	{
		$xml  = '<?xml version="1.0" encoding="ISO-8859-1" ?>'."\n";
		return $xml;
	}

	function _distribution2XML( $item, $version = true )
	{
		$xml .= '<distribution'; 
		if($version) {
			$xml .= ' version="1.0"';
		}
		$xml .= '>'."\n";
		$xml .= '	<name>'.$item['name'].'</name>'."\n";
		$xml .= '	<summary>'.$item['summary'].'</summary>'."\n";
		$xml .= '	<description>'.$item['description'].'</description>'."\n";
		$xml .= '	<homepage>'.$item['homepage'].'</homepage>'."\n";
		if(is_array($item["maintainer"]) && count($item["maintainer"])) {
			$xml .= '	<maintainers>'."\n";
			foreach($item["maintainer"] as $maintainer) {
				$xml .= '		<maintainer>'."\n";
				$xml .= '			<user>'.$maintainer['user'].'</user>'."\n";
				$xml .= '			<name>'.$maintainer['name'].'</name>'."\n";
				$xml .= '			<email>'.$maintainer['email'].'</email>'."\n";
				$xml .= '			<role>'.$maintainer['role'].'</role>'."\n";
				$xml .= '		</maintainer>'."\n";
			}
			$xml .= '	<maintainers>'."\n";
		}
		$xml .= '	<release>'."\n";
		$xml .= '		<version>'.$item['version'].'</version>'."\n";
		$xml .= '		<date>'.$item['date'].'</date>'."\n";
		$xml .= '		<state>'.$item['state'].'</state>'."\n";
		$xml .= '		<notes>'.$item['notes'].'</notes>'."\n";
		$xml .= '	</release>'."\n";
		$xml .= '	<filelist>'."\n";
		$xml .= '		<descriptor role="applications">'.ZZOSS_Framework::conf('zzoss_framework/paths/url').'get/distribution/'.$item['name'].'-'.$item['version'].'/applications.xml</descriptor>'."\n";
		$xml .= '	</filelist>'."\n";
		$xml .= '</distribution>'."\n";
		return $xml;
	}

	function distribution2XML( $item )
	{
		$xml  = $this->_getXMLHeader();
		$xml .= $this->_distribution2XML( $item );
		return $xml;
	}
	
	function distributions2XML( $items )
	{
		$xml = $this->_getXMLHeader();
		$xml .= '<distributions version="1.0">'."\n";
		if(is_array($items)) {
			foreach($items as $key => $item) {
				if(is_integer($key)) {
					$xml .= $this->_distribution2XML( $item, false );
				}
			}
		}
		$xml .= '</distributions>'."\n";
		return $xml;
	}
}
?>
--- NEW FILE: PackageRepository.php ---
<?php
/**
* This is a class for handling i/o functions
* for packages in the repository
*
* @package com.zzoss.zis.lib
* @version $Id: PackageRepository.php,v 1.1 2004/01/14 16:42:31 czonsius Exp $
* @author Christian Zonsius <[email protected]>
* @copyright 2001-2003 ZZOSS GbR, http://www.zzoss.com
* @license GPL
*/

require_once 'Archive/Tar.php';
require_once 'ZZOSS_Installer_Server/Config.php';
require_once 'ZZOSS_Installer_Server/ApplicationRepository.php';
require_once 'ZZOSS_Installer_Server/PackageXMLOutput.php';

/**   
 * This class provides functions for the package
 * repository
 *   
 * @version  1   
 * @author   Christian Zonsius <[email protected]>; |    
 */   

class ZZOSS_PackageRepository
{

	var $connectors;

	var $dirPackageXMLSource;
	
	var $dirPackageFileSource;
	
	function getPackage( $ddo )
	{
		// set criteria
		$criteria = array(
						'_ddo' => '= "'.$ddo.'"'
					 );
		// retrieve package
		$package = $this->connectors['retrieval']->call('getRecord', array( $criteria ) );
		return $package;
	}

	function getPackageByID( $id )
	{
		// set criteria
		$criteria = array(
						'_id' => '= "'.$id.'"'
					 );
		// retrieve package
		$package = $this->connectors['retrieval']->call('getRecord', array( $criteria ) );
		return $package;
	}

	function getPackageByName( $name )
	{
		// set criteria
		$criteria = array(
						'name' => '= "'.$name.'"'
					 );
		// retrieve package
		$package = $this->connectors['retrieval']->call('getRecord', array( $criteria ) );
		return $package;
	}

	function getPackageByNameVersion( $name, $version )
	{
		// set criteria
		$criteria = array(
						'name' => '= "'.$name.'"',
						'version' => '= "'.$version.'"'
					 );
		// retrieve package
		$package = $this->connectors['retrieval']->call('getRecord', array( $criteria ) );
		return $package;
	}
	
	function getPackageByNameVersionXML( $name, $version )
	{
		$package = $this->getPackageByNameVersion( $name, $version );
		if(file_exists($this->dirPackageXMLSource.$package['xml_url'])) {
			$xml = file_get_contents($this->dirPackageXMLSource.$package['xml_url']);
		}
		return $xml;
	}
	
	function listPackages($application_ddo = null)
	{
		if($application_ddo != null) {
			$packages = array();
			$applicationRepository = new ZZOSS_ApplicationRepository();
			$application = $applicationRepository->getApplication( $application_ddo );
			if(is_array($application['package'])) {
				foreach($application['package'] as $item) {
					$package = $this->getPackageByID( $item['id'] );
					array_push( $packages, $package );
				}
			}
		} else {
			$packages = $this->connectors['retrieval']->call('listRecords', array());
		}
		return $packages;
	}
	
	function getXMLArray( $package )
	{
		// compose path
		$fileXML = $this->dirPackageXMLSource.$package['name'].'-'.$package['version'].'.xml';
		if(file_exists($fileXML)) {
			// create parser object
	        $config = new ZZOSS_InstallerConfig(array('cache' => false, 'numeric' => array('dep','file', 'build', 'maintainer')));
	        $config->setFile($fileXML);
    	    $xml = $config->query('/package');
			return $xml;
		} else {
			return false;
		}
	}
	
	function listPackagesXML($application_ddo = null)
	{
		$packages = $this->listPackages($application_ddo);
		$xml = $this->packages2XML( $packages );
		return $xml;
	}
	
	function removePackage( $ddo )
	{
		// set criteria
		$criteria = array(
						'_ddo' => $ddo
					 );
		// remove package
		// TODO: extend zzoss repository connector with deleteRecords method
		$this->connectors['manipulation']->call('deleteRecords', array( $criteria ) );
		// TODO: unlink tgz / package xml from filesystem
		// TODO: unlink assignments in other applications
	}
	
	function importPackage( $fileTgz )
	{
		// check if file exists
		if(!file_exists($fileTgz)) {
			return PEAR::raiseError('file "'.$fileTgz.'" not found');
		}
		// get temporary directory
		$tmp_dir  = ZZOSS_Framework::conf('zzoss_framework/paths/data').'tmp/';
		$tmp_dir .= uniqID('tmp').'/';
		ZZOSS_FrameworkUtils::mkdir($tmp_dir);
		// extract tgz file
		$tar = new Archive_Tar($fileTgz);
        if (!@$tar->extractModify($tmp_dir)) {
            return PEAR::raiseError("unable to unpack $fileTgz");
        }
		// check for package.xml
		$fileXML = $tmp_dir.'package.xml';
		if(!file_exists($fileXML)) {
			return PEAR::raiseError('invalid package "'.$fileTgz.'"');
		}
		// create parser object
        $config = new ZZOSS_InstallerConfig(array('cache' => false, 'numeric' => array('dep','file', 'build', 'maintainer')));
        $config->setFile($fileXML);
        $xml = $config->query('/package');
		// move file to tgz directory
		$fileXML_norm = $xml['name'].'-'.$xml['release']['version'].'.xml';
		$fileTgz_norm = $xml['name'].'-'.$xml['release']['version'].'.tgz';
		if(!is_dir($this->dirPackageXMLSource)) {
			ZZOSS_FrameworkUtils::mkdir($this->dirPackageXMLSource);
		}
		if(!is_dir($this->dirPackageFileSource)) {
			ZZOSS_FrameworkUtils::mkdir($this->dirPackageFileSource);
		}
		ZZOSS_FrameworkUtils::copy($fileXML, $this->dirPackageXMLSource.$fileXML_norm);
		ZZOSS_FrameworkUtils::copy($fileTgz, $this->dirPackageFileSource.$fileTgz_norm);
		// finally remove temporary directory
		ZZOSS_FrameworkUtils::rmdir($tmp_dir);
		// add package to repository
		$item = array();
		$item['name'] = $xml['name'];
		$item['version'] = $xml['release']['version'];
		$item['summary'] = $xml['summary'];
		$item['state'] = $xml['release']['state'];
		$this->_addPackage( $item, $fileXML_norm, $fileTgz_norm );
		// debug
		print_r($xml);
	}
	
	function _addPackage( $item, $fileXML, $fileTgz )
	{
		// check file paths
		if(!file_exists($this->dirPackageXMLSource.$fileXML)) {
			return PEAR::raiseError('file "'.$this->dirPackageXMLSource.$fileXML.'" not found');
		}
		if(!file_exists($this->dirPackageFileSource.$fileTgz)) {
			return PEAR::raiseError('file "'.$this->dirPackageFileSource.$fileTgz.'" not found');
		}
		// assign file paths to item
		$item['xml_url'] = $fileXML;
		$item['download_url'] = $fileTgz;
		$this->connectors['manipulation']->call( 'addRecord', array( $item ));
	}

	function packages2XML($items)
	{
		$xml = $this->output->packages2XML($items);
		return $xml;
	}
	
	function ZZOSS_PackageRepository()
	{
		// get manipulation connector
		$this->connectors['manipulation'] = ZZOSS_Framework::connect('zzoss_package_repository/connector/manipulation');
		// get retrieval connector
		$this->connectors['retrieval'] = ZZOSS_Framework::connect('zzoss_package_repository/connector/retrieval');
		// set xml directory
		$this->dirPackageXMLSource = ZZOSS_Framework::conf('zzoss_framework/paths/data').'zzoss_installer_server/xml/';
		// set tgz directory
		$this->dirPackageFileSource = ZZOSS_Framework::conf('zzoss_framework/paths/data').'zzoss_installer_server/tgz/';
		// set output object
		$this->output =& new ZZOSS_PackageXMLOutput();
	}

}

?>
--- NEW FILE: PackageXMLOutput.php ---
<?php
/**
* This is a class for handling I/O functions
* for distributions in the repository
*
* @package com.zzoss.zis.lib
* @version $Id: PackageXMLOutput.php,v 1.1 2004/01/14 16:42:31 czonsius Exp $
* @author Christian Zonsius <[email protected]>
* @copyright 2001-2003 ZZOSS GbR, http://www.zzoss.com
* @license GPL
*/

/**   
 * This class provides functions for XML export of
 * packages
 *   
 * @version  1   
 * @author   Christian Zonsius <[email protected]>; |    
 */   
 
class ZZOSS_PackageXMLOutput {

	function _getXMLHeader()
	{
		$xml  = '<?xml version="1.0" encoding="ISO-8859-1" ?>'."\n";
		return $xml;
	}

	function _packageItem2XML( $package )
	{
		$xml  = '	<package>'."\n";
		$xml .= '		<name>'.$package['name'].'</name>'."\n";
		$xml .= '		<summary>'.$package['summary'].'</summary>'."\n";
		$xml .= '		<release>'."\n";
		$xml .= '			<version>'.$package['version'].'</version>'."\n";
		$xml .= '			<state>'.$package['state'].'</state>'."\n";
		$xml .= '		</release>'."\n";
		$xml .= '		<filelist>'."\n";
		$xml .= '			<descriptor type="package">'.ZZOSS_Framework::conf('zzoss_framework/paths/url').'get/package/'.$package['name'].'-'.$package['version'].'/package.xml</descriptor>'."\n";
		$xml .= '		</filelist>'."\n";
		$xml .= '	</package>'."\n";
		return $xml;
	}
	
	function packages2XML( $packages )
	{
		$xml  = $this->_getXMLHeader();
		$xml .= '<packages version="1.0">'."\n";
		if(is_array($packages)) {
			foreach($packages as $key => $package) {
				if(is_integer($key)) {
					$xml .= $this->_packageItem2XML( $package );
				}
			}
		}
		$xml .= '</packages>'."\n";
		return $xml;
	}

}
?>
--- NEW FILE: package.xml ---
<?xml version="1.0" encoding="ISO-8859-1" ?>
<package version="1.0"
	xmlns="http://www.zzoss.com/NS/installer/package/">
	<name>com.zzoss.zis.lib</name>
	<summary>ZZ/OSS Installer Server Lib files</summary>
	<description>This package contains libraries for the ZZ/OSS Installer Server.</description>
	<maintainers>
		<maintainer>
			<user>czonsius</user>
			<name>Christian Zonsius</name>
			<email>[email protected]</email>
			<role>developer</role>
		</maintainer>
	</maintainers>
	<release>
		<version>0.5</version>
		<date>2004-01-04</date>
		<license url="http://www.gnu.org/licenses/gpl.txt" version="2">GPL</license>
		<state>beta</state>
		<notes>Initial release.</notes>
		<copyright>
			<holder year="2003" url="http://www.zzoss.com">ZZ/OSS Information Networking GbR</holder>
		</copyright>
		<deps>
	      <dep type="pkg" rel="ge" version="0.5">com.zzoss.application_repository.build</dep>
	      <dep type="pkg" rel="ge" version="0.5">com.zzoss.distribution_repository.build</dep>
    	  <dep type="pkg" rel="ge" version="0.5">com.zzoss.package_repository.build</dep>
	    </deps>
    <filelist>
      	<file role="php" baseinstalldir="ZZOSS_Installer_Server" name="ApplicationRepository.php"/>
      	<file role="php" baseinstalldir="ZZOSS_Installer_Server" name="ApplicationXMLOutput.php"/>
		<file role="php" baseinstalldir="ZZOSS_Installer_Server" name="Config.php"/>
		<file role="php" baseinstalldir="ZZOSS_Installer_Server" name="DistributionRepository.php"/>
		<file role="php" baseinstalldir="ZZOSS_Installer_Server" name="DistributionXMLOutput.php"/>
		<file role="php" baseinstalldir="ZZOSS_Installer_Server" name="PackageRepository.php"/>
		<file role="php" baseinstalldir="ZZOSS_Installer_Server" name="PackageXMLOutput.php"/>
    </filelist>
	</release>
</package>




-------------------------------------------------------
This SF.net email is sponsored by: Perforce Software.
Perforce is the Fast Software Configuration Management System offering
advanced branching capabilities and atomic changes on 50+ platforms.
Free Eval! http://www.perforce.com/perforce/loadprog.html