<?php
/*
 * CVM is more free software. It is licensed under the WTFPL, which
 * allows you to do pretty much anything with it, without having to
 * ask permission. Commercial use is allowed, and no attribution is
 * required. We do politely request that you share your modifications
 * to benefit other developers, but you are under no enforced
 * obligation to do so :)
 * 
 * Please read the accompanying LICENSE document for the full WTFPL
 * licensing text.
 */
 
if(!isset($_CVM)) { die("Unauthorized."); }

class Vps extends CPHPDatabaseRecordClass
{
	public $table_name = "containers";
	public $fill_query = "SELECT * FROM containers WHERE `Id` = :Id";
	public $verify_query = "SELECT * FROM containers WHERE `Id` = :Id";
	
	public $prototype = array(
		'string' => array(
			'Hostname'		=> "Hostname",
			'InternalId'		=> "InternalId",
			'RootPassword'		=> "RootPassword"
		),
		'numeric' => array(
			'NodeId'		=> "NodeId",
			'TemplateId'		=> "TemplateId",
			'UserId'		=> "UserId",
			'VirtualizationType'	=> "VirtualizationType",
			'DiskSpace'		=> "DiskSpace",
			'GuaranteedRam'		=> "GuaranteedRam",
			'BurstableRam'		=> "BurstableRam",
			'CpuCount'		=> "CpuCount",
			'Status'		=> "Status",
			'IncomingTrafficUsed'	=> "IncomingTrafficUsed",
			'IncomingTrafficLast'	=> "IncomingTrafficLast",
			'OutgoingTrafficUsed'	=> "OutgoingTrafficUsed",
			'OutgoingTrafficLast'	=> "OutgoingTrafficLast",
			'IncomingTrafficLimit'	=> "IncomingTrafficLimit",
			'OutgoingTrafficLimit'	=> "OutgoingTrafficLimit",
			'TotalTrafficLimit'	=> "TotalTrafficLimit"
		),
		'node' => array(
			'Node'			=> "NodeId"
		),
		'template' => array(
			'Template'		=> "TemplateId"
		),
		'user' => array(
			'User'			=> "UserId"
		)
	);
	
	public function __get($name)
	{
		switch($name)
		{
			case "sRamUsed":
				return $this->GetRamUsed();
				break;
			case "sRamTotal":
				return $this->GetRamTotal();
				break;
			case "sDiskUsed":
				return $this->GetDiskUsed();
				break;
			case "sDiskTotal":
				return $this->GetDiskTotal();
				break;
			case "sBandwidthUsed":
				return $this->GetBandwidthUsed();
				break;
			case "sCurrentStatus":
				return (int)$this->GetCurrentStatus();
				break;
			case "sStatusText":
				return $this->GetStatusText();
				break;
			default:
				return parent::__get($name);
				break;
		}
	}
	
	public function GetBandwidthUsed()
	{
		return ($this->sOutgoingTrafficUsed + $this->IncomingTrafficUsed) / (1024 * 1024);
	}
	
	public function GetCurrentStatus()
	{
		if($this->sStatus == CVM_STATUS_SUSPENDED || $this->sStatus == CVM_STATUS_TERMINATED)
		{
			return $this->sStatus;
		}
		else
		{
			try
			{
				$command = array("sudo", "vzctl", "status", $this->sInternalId);
				
				$result = $this->sNode->ssh->RunCommandCached($command, false);
				
				if($result->returncode == 0)
				{
					$values = split_whitespace($result->stdout);
					
					if($values[4] == "running")
					{
						return CVM_STATUS_STARTED;
					}
					else
					{
						return CVM_STATUS_STOPPED;
					}
				}
			}
			catch (SshCommandException $e)
			{
				return CVM_STATUS_STOPPED;
			}
		}
	}
	
	public function GetStatusText()
	{
		/* TODO: Add several more options:
		 *  - unknown
		 *  - deleted / non-existent
		 *  - terminated
		 */
		
		$status = $this->sCurrentStatus;
	
		if($status == CVM_STATUS_STARTED)
		{
			return "running";
		}
		elseif($status == CVM_STATUS_STOPPED)
		{
			return "stopped";
		}
		elseif($status == CVM_STATUS_SUSPENDED)
		{
			return "suspended";
		}
		else
		{
			return "unknown";
		}
	}
	
	public function GetRamUsed()
	{
		$ram = $this->GetRam();
		return $ram['used'];
	}
	
	public function GetRamTotal()
	{
		$ram = $this->GetRam();
		return $ram['total'];
	}
	
	public function GetRam()
	{
		try
		{
			$result = $this->RunCommandCached("free -m", true);
			$lines = explode("\n", $result->stdout);
			array_shift($lines);
			
			$total_free = 0;
			$total_used = 0;
			$total_total = 0;

			foreach($lines as $line)
			{
				$line = trim($line);
				$values = split_whitespace($line);
				
				if(trim($values[0]) == "Mem:")
				{
					$total_total = $values[1];
					$total_used = $values[2];
					$total_free = $values[3];
				}
				
			}
		}
		catch (SshCommandException $e)
		{
			$total_free = 0;
			$total_used = 0;
			$total_total = 0;
		}
		
		return array(
			'free'	=> $total_free,
			'used'	=> $total_used,
			'total'	=> $total_total
		);
	}
	
	public function GetDiskUsed()
	{
		$disk = $this->GetDisk();
		return $disk['used'];
	}
	
	public function GetDiskTotal()
	{
		$disk = $this->GetDisk();
		return $disk['total'];
	}
	
	public function GetDisk()
	{
		try
		{
			$result = $this->RunCommandCached("df -l -x tmpfs", true);
			$lines = explode("\n", $result->stdout);
			array_shift($lines);
			
			$total_free = 0;
			$total_used = 0;
			$total_total = 0;
			
			foreach($lines as $disk)
			{
				$disk = trim($disk);
				
				if(!empty($disk))
				{
					$values = split_whitespace($disk);
					$total_free += (int)$values[3] / 1024;
					$total_used += (int)$values[2] / 1024;
					$total_total += ((int)$values[2] + (int)$values[3]) / 1024;
				}
			}
		}
		catch (SshCommandException $e)
		{
			$total_free = 0;
			$total_used = 0;
			$total_total = 0;
		}
		
		return array(
			'free'	=> $total_free,
			'used'	=> $total_used,
			'total'	=> $total_total
		);
	}
	
	public function CheckAllowed()
	{
		if($this->sStatus == CVM_STATUS_SUSPENDED)
		{
			throw new VpsSuspendedException("No operations can be performed on this VPS beacuse it is suspended.", 1, $this->sInternalId);
		}
		elseif($this->sStatus == CVM_STATUS_TERMINATED)
		{
			throw new VpsSuspendedException("No operations can be performed on this VPS beacuse it is terminated.", 1, $this->sInternalId);
		}
		else
		{
			return true;
		}
	}
	
	public function SetOptions($options)
	{
		if(is_array($options))
		{
			$command_elements = array("sudo", "vzctl", "set", $this->sInternalId);
			
			foreach($options as $key => $value)
			{
				$command_elements[] = "--{$key}";
				$command_elements[] = $value;
			}
			
			$command_elements[] = "--save";
			
			$this->sNode->ssh->RunCommand($command_elements, true);
		}
		else
		{
			throw new InvalidArgumentException("The option argument to Vps::SetOptions should be an array.");
		}
	}
	
	public function RunCommand($command, $throw_exception = false)
	{
		return $this->sNode->ssh->RunCommand(array("sudo", "vzctl", "exec", $this->sInternalId, $command), $throw_exception);
	}
	
	public function RunCommandCached($command, $throw_exception = false)
	{
		return $this->sNode->ssh->RunCommandCached(array("sudo", "vzctl", "exec", $this->sInternalId, $command), $throw_exception);
	}
	
	public function Deploy($conf = array())
	{
		$sRootPassword = random_string(20);
		
		$this->uRootPassword = $sRootPassword;
		$this->InsertIntoDatabase();
		
		$command = array("sudo", "vzctl", "create", $this->sInternalId, "--ostemplate", $this->sTemplate->sTemplateName);
		
		$result = $this->sNode->ssh->RunCommand($command, false);
		$result->returncode = 0;

		if($result->returncode == 0 && strpos($result->stderr, "ERROR") === false)
		{
			$this->uStatus = CVM_STATUS_CREATED;
			$this->InsertIntoDatabase();
			
			$dummy_processes = 1000;
			$dummy_files = $this->sGuaranteedRam * 32;
			$dummy_sockets = $this->sGuaranteedRam * 3;
			
			$sKMemSize = (isset($conf['sKMemSize'])) 		? $conf['sKMemSize'] : 		(40 * 1024 * ($dummy_processes / 2)) + ($dummy_files * 384 * 100);
			$sKMemSizeLimit = (isset($conf['sKMemSizeLimit'])) 	? $conf['sKMemSizeLimit'] : 	(int)($sKMemSize * 1.1);
			$sLockedPages = (isset($conf['sLockedPages'])) 		? $conf['sLockedPages'] : 	$dummy_processes;
			$sShmPages = (isset($conf['sShmPages'])) 		? $conf['sShmPages'] : 		$this->sGuaranteedRam . "M";
			$sOomGuarPages = (isset($conf['sOomGuarPages'])) 	? $conf['sOomGuarPages'] : 	$this->sGuaranteedRam . "M";
			$sTcpSock = (isset($conf['sTcpSock'])) 			? $conf['sTcpSock'] : 		$dummy_sockets;
			$sOtherSock = (isset($conf['sOtherSock'])) 		? $conf['sOtherSock'] : 	$dummy_sockets;
			$sFLock = (isset($conf['sFLock'])) 			? $conf['sFLock'] : 		$dummy_processes;
			$sFLockLimit = (isset($conf['sFLockLimit'])) 		? $conf['sFLockLimit'] : 	(int)($sFLock * 1.1);
			$sTcpSndBuf = (isset($conf['sTcpSndBuf'])) 		? $conf['sTcpSndBuf'] : 	round($this->sGuaranteedRam * 1024 / 5) . "K";
			$sTcpRcvBuf = (isset($conf['sTcpRcvBuf'])) 		? $conf['sTcpRcvBuf'] : 	round($this->sGuaranteedRam * 1024 / 5) . "K";
			$sOtherBuf = (isset($conf['sOtherBuf'])) 		? $conf['sOtherBuf'] : 		round($this->sGuaranteedRam * 1024 / 5) . "K";
			$sOtherBufLimit = (isset($conf['sOtherBufLimit'])) 	? $conf['sOtherBufLimit'] : 	(int)($sOtherBuf + (2 * $dummy_processes * 16));
			$sTcpSndBufLimit = (isset($conf['sTcpSndBufLimit'])) 	? $conf['sTcpSndBufLimit'] : 	(int)($sTcpSndBuf + (2 * $dummy_processes * 16));
			$sTcpRcvBufLimit = (isset($conf['sTcpRcvBufLimit'])) 	? $conf['sTcpRcvBufLimit'] : 	(int)($sTcpRcvBuf + (2 * $dummy_processes * 16));
			$sDgramBuf = (isset($conf['sDgramBuf'])) 		? $conf['sDgramBuf'] : 		round($this->sGuaranteedRam * 1024 / 5) . "K";
			$sNumFile = (isset($conf['sNumFile'])) 			? $conf['sNumFile'] : 		$dummy_files;
			$sNumProc = (isset($conf['sNumProc'])) 			? $conf['sNumProc'] : 		$dummy_processes;
			$sDCache = (isset($conf['sDCache'])) 			? $conf['sDCache'] : 		$dummy_files * 384;
			$sDCacheLimit = (isset($conf['sDCacheLimit'])) 		? $conf['sDCacheLimit'] : 	(int)($sDCache * 1.1);
			$sAvgProc = (isset($conf['sAvgProc'])) 			? $conf['sAvgProc'] : 		$dummy_processes / 2;
			
			$command = array("sudo", "vzctl", "set", $this->sInternalId,
				"--onboot", "yes",
				"--setmode", "restart",
				"--hostname", $this->sHostname,
				"--nameserver", "8.8.8.8",
				"--nameserver", "8.8.4.4",
				"--numproc", $this->sCpuCount,
				"--vmguarpages", "{$this->sGuaranteedRam}M:unlimited",
				"--privvmpages", "{$this->sBurstableRam}M:{$this->sBurstableRam}M",
				"--quotatime", "0",
				"--diskspace", "{$this->sDiskSpace}M:{$this->sDiskSpace}M",
				"--userpasswd", "root:{$sRootPassword}",
				"--kmemsize", "{$sKMemSize}:{$sKMemSizeLimit}",
				"--lockedpages", "{$sLockedPages}:{$sLockedPages}",
				"--shmpages", "{$sShmPages}:{$sShmPages}",
				"--physpages", "0:unlimited",
				"--oomguarpages", "{$sOomGuarPages}:unlimited",
				"--numtcpsock", "{$sTcpSock}:{$sTcpSock}",
				"--numflock", "{$sFLock}:{$sFLockLimit}",
				"--numpty", "32:32",
				"--numsiginfo", "512:512",
				"--tcpsndbuf", "{$sTcpSndBuf}:{$sTcpSndBufLimit}",
				"--tcprcvbuf", "{$sTcpRcvBuf}:{$sTcpRcvBufLimit}",
				"--othersockbuf", "{$sOtherBuf}:{$sOtherBufLimit}",
				"--dgramrcvbuf", "{$sDgramBuf}:{$sDgramBuf}",
				"--numothersock", "{$sOtherSock}:{$sOtherSock}",
				"--numfile", "{$sNumFile}:{$sNumFile}",
				"--numproc", "{$sNumProc}:{$sNumProc}",
				"--dcachesize", "{$sDCache}:{$sDCacheLimit}",
				"--numiptent", "128:128",
				"--diskinodes", "200000:220000",
				"--avnumproc", "{$sAvgProc}:{$sAvgProc}",
				"--save"
			);
			
			/* 
			This may be useful if we turn out to have a kernel that supports vswap
			
			$command = shrink_command("vzctl set {$this->sInternalId}
				--onboot yes
				--setmode restart
				--hostname {$this->sHostname}
				--nameserver 8.8.8.8
				--nameserver 8.8.4.4
				--numproc {$this->sCpuCount}
				--quotatime 0
				--diskspace {$this->sDiskSpace}M:{$this->sDiskSpace}M
				--userpasswd root:{$sRootPassword}
				--numtcpsock 360:360
				--numflock 188:206
				--numpty 16:16
				--numsiginfo 256:256
				--tcpsndbuf 1720320:2703360
				--tcprcvbuf 1720320:2703360
				--othersockbuf 1126080:2097152
				--dgramrcvbuf 262144:262144
				--numothersock 360:360
				--numfile 9312:9312
				--dcachesize 3409920:3624960
				--numiptent 128:128
				--diskinodes 200000:220000
				--avnumproc 180:180
				--ram {$this->sGuaranteedRam}M
				--swap {$this->sBurstableRam}M
				--save
			");*/
			
			$result = $this->sNode->ssh->RunCommand($command, false);
			
			if($result->returncode == 0)
			{
				$this->uStatus = CVM_STATUS_CONFIGURED;
				$this->InsertIntoDatabase();
				
				return true;
			}
			else
			{
				throw new VpsConfigureException($result->stderr, $result->returncode, $this->sInternalId);
			}
		}
		else
		{
			throw new VpsCreateException($result->stderr, $result->returncode, $this->sInternalId);
		}
	}
	
	public function Destroy()
	{
		if($this->sCurrentStatus == CVM_STATUS_STARTED)
		{
			$this->Stop();
		}
		
		$command = array("sudo", "vzctl", "destroy", $this->sInternalId);
		$result = $this->sNode->ssh->RunCommand($command, false);
		
		if($result->returncode == 0)
		{
			return true;
		}
		else
		{
			throw new VpsDestroyException("Destroying VPS failed: {$result->stderr}", $result->returncode, $this->sInternalId);
		}
	}
	
	public function Reinstall()
	{
		try
		{
			$this->Destroy();
			$this->Deploy();
		}
		catch (VpsDestroyException $e)
		{
			throw new VpsReinstallException("Reinstalling VPS failed during destroying: " . $e->getMessage(), $e->getCode(), $this->sInternalId, $e);
		}
		catch (VpsCreateException $e)
		{
			throw new VpsReinstallException("Reinstalling VPS failed during creation: " . $e->getMessage(), $e->getCode(), $this->sInternalId, $e);
		}
		catch (VpsConfigureException $e)
		{
			throw new VpsReinstallException("Reinstalling VPS failed during configuration: " . $e->getMessage(), $e->getCode(), $this->sInternalId, $e);
		}
	}
	
	public function Start($forced = false)
	{
		if($this->sStatus == CVM_STATUS_SUSPENDED && $forced == false)
		{
			throw new VpsSuspendedException("The VPS cannot be started as it is suspended.", 1, $this->sInternalId);
		}
		elseif($this->sStatus == CVM_STATUS_TERMINATED && $forced == false)
		{
			throw new VpsTerminatedException("The VPS cannot be started as it is terminated.", 1, $this->sInternalId);
		}
		else
		{
			$command = array("sudo", "vzctl", "start", $this->sInternalId);
			$result = $this->sNode->ssh->RunCommand($command, false);
			
			if($result->returncode == 0)
			{
				$this->uStatus = CVM_STATUS_STARTED;
				$this->InsertIntoDatabase();
				return true;
			}
			else
			{
				throw new VpsStartException($result->stderr, $result->returncode, $this->sInternalId);
			}
		}
	}
	
	public function Stop()
	{
		if($this->sStatus == CVM_STATUS_SUSPENDED)
		{
			throw new VpsSuspendedException("The VPS cannot be stopped as it is suspended.", 1, $this->sInternalId);
		}
		elseif($this->sStatus == CVM_STATUS_TERMINATED)
		{
			throw new VpsTerminatedException("The VPS cannot be stopped as it is terminated.", 1, $this->sInternalId);
		}
		else
		{
			$command = array("sudo", "vzctl", "stop", $this->sInternalId);
			$result = $this->sNode->ssh->RunCommand($command, false);
			
			/* vzctl is retarded enough to return code 0 when the command fails because the container isn't running,
			 * so we'll have to check stderr for specific error strings as well. Come on guys, it's 2012. */
			if($result->returncode == 0 && strpos($result->stderr, "Unable to stop") === false)
			{
				$this->uStatus = CVM_STATUS_STOPPED;
				$this->InsertIntoDatabase();
				return true;
			}
			else
			{
				throw new VpsStopException($result->stderr, $result->returncode, $this->sInternalId);
			}
		}
	}
	
	public function Suspend()
	{
		if($this->sStatus != CVM_STATUS_SUSPENDED)
		{
			try
			{
				$this->Stop();
				$this->uStatus = CVM_STATUS_SUSPENDED;
				$this->InsertIntoDatabase();
			}
			catch (VpsStopException $e)
			{
				throw new VpsSuspendException("Suspension failed as the VPS could not be stopped.", 1, $this->sInternalId, $e);
			}
		}
		else
		{
			throw new VpsSuspendException("The VPS is already suspended.", 1, $this->sInternalId);
		}
	}
	
	public function Unsuspend()
	{
		if($this->sStatus == CVM_STATUS_SUSPENDED)
		{
			try
			{
				$this->Start(true);
				$this->uStatus = CVM_STATUS_STARTED;
				$this->InsertIntoDatabase();
			}
			catch (VpsStartException $e)
			{
				throw new VpsUnsuspendException("Unsuspension failed as the VPS could not be started.", 1, $this->sInternalId, $e);
			}
		}
		else
		{
			throw new VpsUnsuspendException("The VPS is not suspended.", 1, $this->sInternalId);
		}
	}
	
	public function AddIp($ip)
	{
		$command = array("sudo", "vzctl", "set", $this->sInternalId, "--ipadd", $ip, "--save");
		
		$result = $this->sNode->ssh->RunCommand($command, false);
		
		if($result->returncode == 0)
		{
			return true;
		}
		else
		{
			throw new VpsIpAddException($result->stderr, $result->returncode, $this->sInternalId);
		}
	}
	
	public function RemoveIp($ip)
	{
		$command = array("sudo", "vzctl", "set", $this->sInternalId, "--ipdel", $ip, "--save");
		
		$result = $this->sNode->ssh->RunCommand($command, false);
		
		if($result->returncode == 0)
		{
			return true;
		}
		else
		{
			throw new VpsIpRemoveException($result->stderr, $result->returncode, $this->sInternalId);
		}
	}
	
	public function UpdateTraffic()
	{
		/* TODO: Don't rely on grep, and parse the output in this function itself. Also try to find another way to do this without relying
		 * on the container at all. */
		$result = $this->sNode->ssh->RunCommand(array("sudo", "vzctl", "exec", $this->sInternalId, "cat /proc/net/dev | grep venet0"), false);
		
		if($result->returncode == 0)
		{
			$lines = split_lines($result->stdout);
			$values = split_whitespace(str_replace(":", " ", $lines[0]));
			
			$uIncoming = $values[1];
			$uOutgoing = $values[9];
			
			if($uIncoming < (int)$this->sIncomingTrafficLast || $uOutgoing < (int)$this->sOutgoingTrafficLast)
			{
				// the counter has reset (wrap-around, reboot, etc.)
				$uNewIncoming = $uIncoming;
				$uNewOutgoing = $uOutgoing;
			}
			else
			{
				$uNewIncoming = $uIncoming - $this->sIncomingTrafficLast;
				$uNewOutgoing = $uOutgoing - $this->sOutgoingTrafficLast;
			}
			
			$this->uIncomingTrafficUsed = $this->sIncomingTrafficUsed + $uNewIncoming;
			$this->uOutgoingTrafficUsed = $this->sOutgoingTrafficUsed + $uNewOutgoing;
			
			$this->uIncomingTrafficLast = $uIncoming;
			$this->uOutgoingTrafficLast = $uOutgoing;
			
			$this->InsertIntoDatabase();
		}
		else
		{
			throw new VpsTrafficRetrieveException($result->stderr, $result->returncode, $this->sInternalId);
		}
	}
	
	public function SetRootPassword($password)
	{
		if($this->sStatus == CVM_STATUS_SUSPENDED)
		{
			throw new VpsSuspendedException("The root password cannot be changed, because the VPS is suspended.", 1, $this->sInternalId);
		}
		elseif($this->sStatus == CVM_STATUS_TERMINATED)
		{
			throw new VpsTerminatedException("The root password cannot be changed, because the VPS is terminated.", 1, $this->sInternalId);
		}
		else
		{
			$this->SetOptions(array(
				'userpasswd'	=> "root:{$password}"
			));
		}
	}
	
	public function EnableTunTap()
	{
		/* TODO: Finish EnableTunTap function, check whether tun module is available on host */
		$command = array("sudo", "vzctl", "set", $this->sInternalId, "--devnodes", "net/tun:rw", "--save");
	}
}