1. Download and install VMware Player. This is VMware’s entry-level free virtualization product for end users.
2. Instead of downloading a file from the Android x86 project, I grabbed a customized one with better support for VMWare drivers from Dan Fages. Download the android-x86-vm-20120130.iso.gz file and extract it somewhere on your computer.
3. Create a New Virtual Machine. Set the “Installer disc image file” to the Android x86 ISO file you just downloaded:
   
4. Configure a name and location to save the disk image. You can set this to 2.5GB:
   1. The Android OS partitions take about 256MB of disk space.
   2. The maximum size for a simulated SD card is 2GB.
5. Once you’ve completed the startup wizard, it should immediately boot to a GRUB menu. Select the “Installation” link to start this process.
   
6. Create/Modify partitions:
   1. Use the arrows keys to select [New]
   2. Then, choose [Primary] to create the first disk partition.
   3. Accept the default (maximum) and hit Enter.
   4. Choose [Bootable] to add the “Boot” flag to the partition.
   5. Select [Write] and confirm your choice to complete partition setup.
      
7. Quit the Partition Editor.
8. Back in the “Choose Partition” window, there should be an option to install Android to “sda1 Linux”. Select this and choose OK.
9. Select ext3 in the “Choose filesystem” window. Confirm when it asks you if you’d like to format the drive, then confirm again when it asks you to install the GRUB boot loader.
10. You probably want to leave the /system drive as read-only. Accept the default and select No when it asks you if you’d like to set this drive as read-write.
11. You’ll have an opportunity, optionally, to Create a fake SD card. Do this, then Reboot the Virtual Machine.
12. In a few moments, you’ll see a prompt asking which Android (“regular” or Debug mode) to boot. Choose the default first-choice, or wait a few moments for it to auto-select the default.
13. Lastly, remember to click the I Finished Installing button. When it asks you about “Installing VMWare Tools”, choose Never Reminder Me.
    

The standard Google Market (Google Play) store isn’t available in this build by default, but you may be able to find applications you’re looking for in the “App Store”. Test out some of the Android Ice Cream Sandwich features here while you wait for your phone to be updated!

There is plenty more that can be done using the “adb” interface if you’re interested in developing or testing other features – but this will get you started if you’re looking for an introduction. Sorry, no iPhone OS emulator just yet!

Edwin Chung
Application Integration Engineer, SPK & Associates

Engineers need the right computers (including PCs, servers and the supporting networks) and the right software (including compilers, design packages, word processing suites, change management tools, etc.) to design, build, test and document the products on which they’re working. With the right tools, engineers can innovate and create new products that will shape the future.

However, because these tools are also complex, they need to be managed. PCs need maintenance, servers need configuring, networks need tuning, software needs upgrading, applications need management, and everything needs to be backed up. Because engineers are highly skilled and conversant in the technology, they choose do this work, rather than turn it over to the system admins in the IT services department.  And let’s be honest, the engineers tend to do the work themselves because IT inadequately meets their needs.

Similarly, when faced with the need for new tools or systems, an engineer often thinks “it will be quicker to do it myself that wait for IT services.” The hands-on engineer moves boldly ahead planning and building new systems without letting IT services know what he’s doing.

The result of this migration of responsibility is threefold.

First: The relationship between the IT services department and the engineers becomes blurred and strained. With both groups working on the same systems, tensions can rise as work is duplicated and/or neglected.

Second: The engineers perform these tasks in an ad-hoc manner. Because the engineers have other responsibilities, the more mundane tasks like backups get left to one side. As pressure increases and deadlines loom, the system management tasks, which the engineers adopted earlier in the project, now become burdens and strains. The flash point is when either a system fails or an application quits working properly.

Third: The third problem, by far the biggest, is that tasks like backups and software upgrades take time away from innovation and design. Good engineers are extremely valuable resources and their creativity needs to be channelled into building products not performing system administration.

To get engineers back on track, the IT services provider needs to respond to the engineers’ needs differently than to the needs of, say, accounting or the human resources department. IT services needs to understand that the engineers are experts and they know what they want and why they want it.  The R&D IT service provider needs to deeply understand engineering requirements and procedures.

Not only that, but engineers need quick response times. Lots of bureaucracy, too many forms to fill out and a slow turnaround will only frustrate engineers and re-enforce the desire to take system management into their own hands.

Additionally, flexibility is essential. Since engineers are innovators, their requests are often innovative and don’t necessarily follow the norm. If they’re “thinking outside of the box” in terms of products, then IT services needs to follow that thinking and support it. Innovation plus flexibility equals great products.

Outsourcing these IT services to an external IT services provider that specializes in supporting Engineering is often the best solution to set your engineers free. It increases efficiency and productivity, reduces costs and offers quick and flexible responses. But most of all it allows engineers the freedom to focus on what they do best – innovate.

Attached is a quick setup guide. Let me know if you have any questions.
Webalizer statistics

For demonstration purposes, this article will be focusing on adding more disk space to a virtual Redhat server which has a single virtual disk of 25G in size. That disk only has 1G of free space, and you need to add another 25G to handle a new application’s install and projected growth.  It’s important to note that you can add more space to existing volume groups in a LVM setup. LVM is the default type of disk management that Redhat uses, so you should already have that setup. If you went the more classic route and just made partitions on the physical disks, this tutorial won’t be much help as you can’t expand existing partitions like that.

With these requirements in place, here’s a quick summary of what we’ll be doing:

1. Present a new physical disk to the server

2. Adding the new physical disk to an exisiting Volume Group.

3. Expanding a logical volume within that Volume Group to use the new disk space.

4. Notify the operating system about the change in size.

Step 1: Present the new physical disk to the server.

This is a fairly easy step. Since we’re setup with a virtual machine, we just need to login to vSphere, shutdown the operating system, and add a new virtual disk through the Settings menu. For our demonstration, I’ll be adding a new 30G disk. If you’re working with a physical server, you would need to add the new hard drive, and make sure the BIOS can see the new drive. Once you have the new drive added (either physical or virtual), start the server up again and let Redhat boot.

Step 2: Add the new physical disk to an existing Volume Group.

Now, let’s verify that we can see the new disk. If you perform an fdisk -l command, you should see the new disk. Here’s a sample output:

Disk /dev/sda: 25.7 GB, 25769803776 bytes
255 heads, 63 sectors/track, 3133 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes

   Device Boot      Start         End      Blocks   Id  System
/dev/sda1   *           1          13      104391   83  Linux
/dev/sda2              14        3133    25061400   8e  Linux LVM

Disk /dev/sdb: 25.7 GB, 25769803776 bytes
255 heads, 63 sectors/track, 3133 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes

Disk /dev/sdb doesn't contain a valid partition table

# vgdisplay

  --- Volume group ---
  VG Name               VolGroup00
  System ID
  Format                lvm2
  Metadata Areas        2
  Metadata Sequence No  7
  VG Access             read/write
  VG Status             resizable
  MAX LV                0
  Cur LV                1
  Open LV               1
  Max PV                0
  Cur PV                1
  Act PV                1
  VG Size               24.84 GB
  PE Size               32.00 MB
  Total PE              1531
  Alloc PE / Size       1529 / 24.78 GB
  Free  PE / Size       2 / 64.00 MB
  VG UUID               QoI2Oi-E8S5-l7o2-4YIo-X3lT-sGXK-kBlhyT

# pvcreate /dev/sdb
  Physical volume "/dev/sdb" successfully created

Now that the disk is a physical volume, it can be added to a volume group. You can do this by using the vgextend command as such:

# vgextend VolGroup00 /dev/sdb
  Volume group "VolGroup00" successfully extended

The new physical volume has now been added to the volume group and is ready to be allocated to a logical volume.

Step 3: Expand the logical volume to use the new space

Next, we need to run the lvextend tool to expand the volume to use the new space. For this command you need to get the path to the logical volume, which you can get by running the lvdisplay command Here’s the command to expand the volume:

# lvextend -L+24.9G /dev/VolGroup00/LogVol00
  Rounding up size to full physical extent 24.90 GB
  Extending logical volume LogVol00 to 47.8 GB
  Logical volume LogVol00 successfully resized

Now we’ve got the new space added, but the filesystem doesn’t know about it yet.

Step 4: Update the filesystem to use the new space

The last step in the process is to resize the file system residing on the logical volume so that it uses the additional space. Since we are running Redhat, we can use the resize2fs command as such:

# resize2fs /dev/VolGroup00/LogVol00
resize2fs 1.41.4 (27-Jan-2009)
Filesystem at /dev/VolGroup00/LogVol00 is mounted on /; on-line resizing required

After a bit of a wait, the OS will present that it’s complete and now our / filesystem has been expanded by roughly 25G! Now you can breath a bit easier.

This is a very basic introduction to LVM and expanding disk sizes, if you’d like more information or want help in expanding your system, feel free to comment below! I’ll be happy to assist.

Bradley Tinder, Systems Integrator, SPK & Associates

In the Beginning

In the beginning, there was an idea. The idea took shape and became a project. The project became an application and the application got used.

Or maybe it didn’t get used. Maybe it was completely the wrong application for the business. Or maybe it was the right application, but no one knew exactly what to do with it.

Although there are many places for a project to go right or wrong, having a clear vision, communicated effectively to the project team, is a good place to start down the right path.

Vision and the SDLC

Maybe your New Year’s resolution is to bone up on the Software Development Lifecycle to see how your current project can be improved. Or maybe you’re about to lead your first new project. Wherever you’re at, be sure to take a step back and review the basics. This installment of SDLC Basics will focus on the creation and documentation of the Vision Statement.

The Scenario

A large software company’s sales force use five applications. One app is to track small business customers; the second app tracks corporate customers; another app tracks government customers; the fourth app is for order management; and the final application is for reports. Oh yes, and then there are the applications for calendars and to-do lists. This doesn’t sound very efficient, does it? So, someone in the company, maybe a sales manager, has an idea to create one application to access the data from the other applications and roll key data points into a dashboard.

Executives meet and the project gets the support to get underway. The Vision Statement is created and communicated to the project team. What should the vision statement look like and how should it be communicated?

Some Dos and Don’ts

• The Vision Statement should be short and to the point, not a multi-page document. Some classic examples from successful businesses are only one sentence long;
• The vision should be clear. It should not be cluttered by verbosity;
• Most (and preferably all) of the project team should “get it”;
• It should not dictate specifics. That will come later in the SDLC;
• It should be something that can pull people back on track when “rabbit trails” have been visited.

An Example

For the scenario above, our Vision Statement could look something like this: “We will develop an application that allows our sales force to quickly see sales data and orders for any customer, anytime, anywhere.”

Effective Communication

Now that a vision has been developed, how is it communicated to the team? One suggestion is to include it in an email, memo or meeting to kick off the project. It should also be written at the top of all project documentation – the project scope and plans, development docs, test docs, etc. It’s the constant reminder to the team of the project’s focal point.

In the next installment of SDLC Basics, we will drill down into the details of a Scope Document.

As part of SPK’s network management service, we find that all customers have very specific environments.  Not only is it common to find custom applications, but customers may also require a varying level of visibility into those apps.  For instance, the out of the box check_http script not only can verify connectivity to a web server, but it also can verify a specific string that should be returned.  But what we if we want dive much deeper?  Can we tell if the application throws any critical back-end errors during the login attempt?  What if logins never fail, but performance slowly degrades?  How can we be alerted to such situations?

These situations call for functionality beyond what the out-of-the box plugins can provide.  Writing a custom plugin might sound like a daunting task, but if you follow my simple guidelines and troubleshooting steps, you’ll be off and running in no time.  Read further on how you can create your own custom Nagios plugins.

Have a special situation that requires monitoring?  Let me know how I can help you integrate a Nagios monitoring solution.

Mike Solinap
Sr. Systems Integrator
SPK & Associates

Maybe the elderly, at 13% of the population, aren’t part of your target market, or maybe it’s the 12% of the US population who are disabled that you aren’t reaching. Many people will not be able to use your software or will become frustrated trying to do so if you haven’t included Software Accessibility Standards in your applications.

If this information convinces you it’s time to integrate accessibility into your current or next project, here are some guidelines to get you started:

Get Management Support

For the successful incorporation of accessibility into your applications, support needs to come from the highest level possible. If you’re at an engineering level, hopefully the information in this blog, and doing a little research on the W3C website, will give you the information you need to make the case to upper management and get the necessary support.

Designate or Hire an Accessibility Expert

If there’s someone on the team (usually a project manager, tester or developer) who has previous software accessibility experience, by all means, take advantage of his knowledge. If you don’t have anyone with such experience, hiring a consulting firm with this experience is a good alternative. However, developing an expert within the team should be the long-term goal.

Get Training

You can get training from companies that specialize in software accessibility or use the internet and books to train your people. The W3C is a good source of high-level information and detailed technical information, including a list of standards.

Include Accessibility from the Beginning

The best case scenario is to include Software Accessibility Standards from the beginning of the life of an application. This means incorporating the standards into your requirements documentation, technical specs, and test plans. If your project already has a few releases, you can incorporate the standards into the next phase/iteration of your product lifecycle.

Test for Accessibility

You should include a W3C-compliant tool as part of your test suite during your project’s stabilization phase. Since no one tool is perfect, it’s good to include some manual test cases to verify the accessibility features as part of your standard test suite.

If your software has already been released, there are a variety of accessibility test tools available on the market to validate the accessibility of your application. In the end, software engineering is about the rapid delivery of high-quality software; and if that includes an accessibility requirement, be sure to consider these guidelines.

IPv6 is the next generation IP protocol designed to address the short comings of the currently used IPv4 protocol. While it is true that casual internet users really do not need to know or really understand the underlying protocol that allows their computer to connect to others over the internet, these users do get concerned when this connection is no longer functional. While things are functional at the present, things are beginning to change at an ever increasing rate. Recently, the organization that delegates the global pool of both IPv4 and IPv6 address spaces, the Internet Assigned Numbers Authority (IANA), depleted its remaining free IPv4 address blocks by assigning them to the regional authorities. While there are still new IPv4 addresses to be had, they are growing scarcer by the day. It is becoming increasingly important for companies and IT departments to begin to concern themselves with this next generation protocol. In the not too distant future, and sooner rather than later in certain parts of the world, businesses and individuals will only be able to obtain an IPv6 address. While there are mechanisms in place which would allow those users to connect to a site with only an IPv4 address, this would not be the native connection and that mechanism would introduce another layer of complexity and another point of failure to the network.

The transition to IPv6 has already taken a long time and, unfortunately, things are only just getting started in earnest. IPv6 has been in the works since the early 1990’s but, as a whole, industry has made very little progress in implementation except in the last few years. Certainly there are many factors that have played a part in the delay – even some of the best known networking product companies have not exactly been doing much to help the IPv6 cause. For example, it was not until the last couple of years that Cisco, arguably the best known networking product manufacturer, supported IPv6 in the base versions of their switch and router operating system, IOS. There is no doubt that a daunting task lie ahead, the world over, in reconfiguring and upgrading every inter-connected device on the internet. And while that is already an impressive amount of work to be done, every day that the transition is delayed, more devices are added to the internet that will have to be reconfigured as a part of this inevitable transition.

We are now standing at the edge of a major transition. This transition will completely change the way the internet works – for the better. IPv4’s days are numbered. The depletion of the address space is just the first problem. Fortunately, the impact of the address depletion was not noticed by casual users of the internet. But subsequent problems will begin to have progressively more noticeable impacts on those same users.

The good news is that IPv6 and the transition to IPv6 need not be scary. IPv6 has many good, and frankly, very cool new features available within the protocol. Learning from the shortcomings in IPv4, engineers built into the design for IPv6 solutions to many of the problems that still plague IPv4 networks today. For example, in the very early days of the internet, every client on the network had a “public” address. As available address space shrunk, engineers addressed the problem by expanding on the idea of private network ranges. These private networks would then have to be translated out of one or many public internet connections. This introduced the concept known as Network Address Translation (NAT). While NAT has prolonged the life of the IPv4 internet, it has also greatly increased the complexity of network configurations – and the salaries of network engineers. In the future, the IPv6 address space is so large, that we will once again be able to return to the simplicity of having end-to-end device connectivity utilizing unique public addresses.

Is your organization prepared for the impending IPv6 transition? In my next post, I will discuss a couple of free services and tools that will provide you the ability to connect yourself to the IPv6 internet which will provide you an invaluable opportunity to learn about this fundamental change to the way the world is connected. In the meantime, if you find that you have more questions than answers regarding what lies ahead, we welcome the opportunity to work with your organization as we address this transition together.

Rusty Wyatt
Network Engineer
SPK and Associates

Here is a quick list of the systems reported on in Speccy:
1. A quick Summary of all the system components
2. Operating System
3. CPU
4. RAM
5. Motherboard
6. Graphics
7. Hard Drives
8. Optical Drives
9. Audio
10. Peripherals
11. Network

You can view the high level information for all the components on the Summary page, or drill down into each separate component and subcomponent. Example: the CPU summary gives manufacturer details, type of processor, speed, and temperature. Then you can drill down and see each core, thread, as well as bus speed, enablement for hyper-threading, visualization, and much more.
All this information is available from the one tool, which does what it does very well. And the price is right – you can get it for free! Of course if you want user support for Speccy, there are paid versions of the tool which will allow for this. My advice: download, install, and try it out. You may find that it is helpful enough that you will want to keep it around.
Speccy is put out by Piriform, and it’s a simple matter to get the free version to evaluate it. Click on SPK_Speccy to read about more of the details. Check back later and let us know about your experiences with Speccy!

Commander makes it possible to eliminate unnecessary lag time between phases of the development process, such as hand-offs between your development team and QA, but almost more importantly, it introduces:

1. S tandardization,
2. R epeatability, and
3. R eliability to your process.

Those three things are key ingredients for producing meaningful metrics.

Out of the box Commander generates a variety of useful statistics as it executes jobs: When a job was launched, who launched it, how long did the whole thing take, how long did specific steps take, what was the outcome, why did a step fail, where artifacts were stored, etc. Commander also allows users to create their own properties, specific to their needs. All of these properties are exposed to the user through a variety of tools, one of which is the GWT (Google Web Toolkit) Commander SDK.

A primary use for the GWT Commander SDK is the creation of custom dashboards to display pertinent metrics. Keep reading as we describe the general process of using the GWT Commander SDK to extract data from Commander for the purpose of developing meaningful metrics.

David Hubbell
SPK Software Engineer