$AcceptedDomains = Get-AcceptedDomain
$ExternalForwardEnabled = Get-Mailbox -Filter {ForwardingAddress -ne $null} -ResultSize Unlimited
$Results = @()
foreach ($ExternalForward in $ExternalForwardEnabled) {
    $Recipient = Get-Recipient $ExternalForward.ForwardingAddress
    if ((($Recipient).PrimarySMTPAddress).Domain -notin ($AcceptedDomains.DomainName).Domain) {
        $Object = New-Object PSObject -Property @{
            DisplayName = $(($ExternalForward).Name)
            Alias = $(($ExternalForward).Alias)
            ExternalAddress = $(($Recipient.PrimarySmtpAddress).ToString())
            ExternalDomain = $($Recipient.PrimarySmtpAddress).Domain
            }
        $Object
        $Results += $Object
        }
    }

$Results | Select DisplayName,Alias,ExternalAddress,ExternalDomain | Sort ExternalDomain

Here is the script – it can be used verbatim on a Synology NAS running the DNSMasq package from http://syndnsmasq.the-ninth.com/.

Edit the DNSMasq file to add an entry ‘addn-hosts’ to point to the hosts file that was just created – for example:
addn-hosts=/root/AdBlock/adblock.uniq

#!/bin/sh
cd ~/AdBlock</code>

echo "# Generated on: $(date +"%D %T")" &gt; adblock

echo "Downloading file from YoYo.org"
wget -O yoyo http://pgl.yoyo.org/as/serverlist.php?hostformat=hosts&amp;showintro=0
wait
echo "Processing YoYo.org file"
cat yoyo | grep "127.0.0.1" | awk '{ print "0.0.0.0\t"$2 }' &gt;&gt; adblock
wait

echo "Downloading file from SomeoneWhoCares.org"
wget -O swc http://someonewhocares.org/hosts/zero/
wait
echo "Processing SomeoneWhoCares.org file"
cat swc | grep "0.0.0.0" | awk '{ print "0.0.0.0\t"$2 }' | grep -v "#" &gt;&gt; adblock
wait

echo "Downloading file from MVPS.org"
wget -O mvps http://winhelp2002.mvps.org/hosts.txt
wait
echo "Processing MVPS.org file"
cat mvps | grep 0.0.0.0 | grep -v "# 0.0.0.0" | awk '{ print "0.0.0.0\t"$2 }' &gt;&gt; adblock
wait

echo "Downloading file from HPHosts"
wget -O hphosts http://hosts-file.net/download/hosts.txt
wait
echo "Processing HPHosts file"
cat hphosts | grep "127.0.0.1" | awk '{ print "0.0.0.0\t"$2 }' &gt;&gt; adblock
wait

echo "Writing changes to zone file"
tr '[A-Z]' '[a-z]' &lt; adblock | sort -f | uniq &gt; adblock.uniq
wait

echo "Reloading DNS Server"
/var/packages/dnsmasq/scripts/start-stop-status stop
/var/packages/dnsmasq/scripts/start-stop-status start
/var/packages/dnsmasq/scripts/start-stop-status status

$from = "vSphereReports@example.com"
$to = @("email@example.com")
$smtpserver = "smtp.example.com"
$vcenterserver = "vc.example.com"

if (!(Get-PSSnapin | where {$_.Name -eq "VMware.VimAutomation.Core"}))
{
	Write-Verbose "Loading the VMWare snapin"
	try
	{
		Add-PSSnapin VMware.VimAutomation.Core -ErrorAction STOP
	}
	catch
	{
		#Snapin not loaded
		Write-Warning $_.Exception.Message
		EXIT
	}
	Connect-VIServer $vcenterserver
}

$log = "$(Get-Date -format "MM-dd-yyyy").csv"

"Datacenter,Cluster,VMHost,ESXVersion,Vendor,Model,BIOSVersion,BIOSDate,CPU,Sockets,Memory(GB),NICs,ConfigIssues" > $log

foreach ($Datacenter in (Get-Datacenter)) {

    foreach ($Cluster in ($Datacenter | Get-Cluster)) {

        foreach ($VMHost in ($Cluster | Get-VMHost)) {
            $VMHostView = $VMHost | Get-View
            $ESXVersion = $VMHostView.Config.Product.FullName
            $Vendor = $VMHostView.Hardware.SystemInfo.Vendor
            $Model = $VMHostView.Hardware.SystemInfo.Model
            $BIOSVersion = $VMHostView.Hardware.BiosInfo.BiosVersion
            $BIOSdate = $VMHostView.Hardware.BiosInfo.releaseDate
            $CPUType = $VMHostView.Hardware.CpuPkg.Description | Get-Unique
            $CPUCount = $VMHostView.Hardware.CpuPkg.Count
            $MemoryGB = ($VMHostView.Hardware.MemorySize)/(1024*1024*1024) -as [int]
            $PhyNics = (($VMHost | Get-VirtualSwitch).Nic).Count
            $ConfigIssues = $VMHost.extensiondata.configissue.fullformattedmessage | Out-String -Stream
            "$Datacenter,$Cluster,$VMhost,$ESXVersion,$Vendor,$Model,$BIOSVersion,$BIOSDate,$CPUType,$CPUCount,$MemoryGB,$PhyNics,$ConfigIssues" >> $log
            }
        }
    }

$head = @'</pre>
<style><!--
p {font-family:Calibri;
    font-size:9pt;
    background-color:yellow; }
body { font-family:Calibri;
       font-size:9pt; }
td, th { border:1px solid black;
         border-collapse:collapse; }
th { color:white;
     background-color:green; }
table, tr, td, th { padding: 2px; margin: 0px }
table { margin-left:50px; }
--></style>
<pre>
'@

$body=import-csv $log | convertto-html -head $head

Send-MailMessage -to $to -from $from -smtpserver $smtpserver -subject "ESX Host Info $(Get-Date -format dd/MM/yyyy)" -body "$($body)" -bodyashtml

To find out the actual space consumed on disk (in GB):

stat <filename-flat>.vmdk | grep Size: | awk '{print (($4*512)/(1024*1024*1024))}'

To find out the total space provisioned (in GB):

stat <filename-flat>.vmdk | grep Size: | awk '{print ($2/(1024*1024*1024))}'

Percent not used:

stat <filename-flat>.vmdk | grep Size: | awk '{print ((($2/(1024*1024*1024))-($4*512)/(1024*1024*1024))/($2/(1024*1024*1024)))*100}'

Here’s the one liner:

ls -lrtR | grep -E "delta" | awk '{total += $5} END {print ((total/1024)/1024/1024)}'

As we discussed earlier, virtualization is the process of breaking the hard link between physical hardware and the operating system.

Virtualization adds a software layer between the hardware and the operating system called a “Hypervisor,” which breaks the hard link between hardware and software, and allows resources to be evenly shared and consumed more efficiently.

One of the key benefits of server virtualization is flexibility. And there are many more benefits. Below are a few areas where virtualization has been a game changer for the traditional IT department:

1. Adding computer resources

The process of adding memory to a physical server in a traditional IT department involved going through a lengthy process of submitting the request, getting approval, placing an order, waiting for parts to arrive and then physically installing the memory.

With virtualization, adding memory means simply editing the configuration of a virtual machine to give it more memory. This can be accomplished in minutes instead of days.

2. Increased resiliency against failures

With virtualization, it is possible to easily protect your environment against host failures.

If one host that runs virtual machines fails, virtual machines can be configured to automatically fail over to another host in your network. In most cases, this failover process is so seamless you would only notice a brief interruption while the virtual machine starts up on the second host. Compare this to the days you would have to spend waiting for replacement parts to arrive if the physical host that ran your mission-critical database or email server failed.

3. Reduced capital and operational costs

Virtualization allows you to buy fewer servers to achieve your business goals, which reduces your capital expenditures. Fewer servers mean reduced power, cooling and space, as well as lower warranty and maintenance costs, which reduces your operational expenses.

The concept of virtualization is not new. It has been around almost as long as computers and networks. Although IBM was an early pioneer of virtualization, VMware has been responsible for permanently changing the IT landscape by bringing virtualization to the masses through its vSphere line of virtualization products.

Some of the most commonly used virtualization platforms include: VMware’s vSphere, Microsoft’s Hyper-V, Red Hat’s KVM and Citrix’s XenServer.

What’s next?

The explosive growth of virtualization is heralding a new era in computing – the “cloud computing” era.

All cloud platforms use some form of virtualization to ensure performance, scalability, reliability and security. We will be discussing how flexible storage, high compute density servers and scalable networks build cloud platforms in upcoming blog posts.

Check out Animate’s cloud platform at www.lexcloud.ca and subscribe to our blog today.

Simply put, server virtualization can be defined as the process of breaking the hard link between physical hardware and the operating system. But what does that mean? To understand the concept of virtualization, let’s consider a traditional desktop.

The traditional setup

There are a few key components that make up a traditional desktop including: the CPU, memory, hard drives, network adapters and display.

These components constitute the desktop’s physical hardware and can be collectively called “compute resources.” On this hardware, we install a compatible operating system to use our favourite apps. The operating system has full access to all the resources the computer has to offer and uses these resources as needed.

The traditional server works in essentially the same way. The physical hardware that makes up one server is used solely by one operating system that runs one or more applications.

The diagram below represents the traditional desktop or server:

While it has always been nice to have all computing resources available to the operating system at all times, research has shown time and time again that compute resources are idle for a majority of the time and, even during times of peak load, these resources are not typically maxed out.

This may not appear to be a problem at a micro level but when scaling up, this creates significant challenges and operational inefficiencies.

Let’s consider a case where a business requires two servers to run a line of business apps. Let’s assume that these servers have the same compute resources available to them, and that these compute resources were chosen carefully to ensure that when the applications hit peak load, there would not be any drop in performance.

Exhaustive research has shown that during a typical work week, the average resource consumption would be much lower than 50% of the total capacity of each server. This leads us to a pure mathematical question. If the average resources consumed by two servers are less than 50% of the total capacity, don’t we only need half as many servers to do the job? The answer is a resounding yes, and this scenario is now possible using virtualization.

Understanding virtualization

Virtualization adds a software layer between the hardware and the operating system called a “Hypervisor,” which breaks the hard link between hardware and software, and allows resources to be evenly shared and consumed more efficiently.

This diagram shows what the traditional desktop would look like after it’s been virtualized:

This next diagram is a logical representation of what a host server running multiple virtual machines would look like. As you can see, you can run multiple virtual machines on a shared host, and you can also have multiple virtual machines running different operating systems with ease.

Each virtual machine can interact independently with other devices, applications, data, resources and users as though it were a separate physical entity. In essence, a virtual machine is no different from a physical machine. It’s just a more flexible version of the traditional server.

But there are far more benefits to server virtualization than just flexibility. Stay tuned for Part 2 of this post, where we’ll go deeper into the benefits of server virtualization.