Information Technology

Iron Mountain's Digital Records Center for Medical Images now offers the option of keeping a copy of data onsite; LiveOffice archives on-premise SharePoint, as well as social networking data.

Here's a look at the most popular network-attached storage devices for SMBs in the $2,000 to $10,000 price range.

Customers can keep a Data Domain deduplication box at SunGard's data centers to restore data online after an outage, though application and server failover remain separate services.

Symantec is preparing to launch a product based on security intellectual property called Data Insight, which will be integrated with Data Loss Prevention, CommandCentral Storage and Enterprise Vault.

LTO-5 is available from Quantum and Overland Storage with others sure to follow soon. LTO-5 offers improvements such as higher capacity and partitioning. But how quickly will tape users embrace this technology?

The storage management tools category in SearchStorage.com's enterprise data storage Products of the Year 2009 awards includes technologies such as storage resource management (SRM) and storage-area network (SAN) management software, performance monitoring, file systems, volume management, virtualization software and security software.

In our last blog of this series Walkthrough of creating a SharePoint 2010 external list using Visual Studio 2010 Beta, we introduced how to create a simple “Hello world” external list in SharePoint 2010 Beta using Business Data Connectivity Designer in Visual Studio 2010 Beta.

In this blog, we will show you how to pull data from an external database into an external list and enable Create, Read, Update and Delete (CRUD) functions to the external list.

First of all, you need to have SharePoint 2010 Public Beta and Visual Studio 2010 installed on your machine in order to complete this walkthrough. We’ll use “Northwind” database as external data source, so if you do not have an existing “Northwind” database available, we’ll walk you through to create a local database using SQL Server Express first (SQL Server Express comes with Visual Studio installation by default, in case you don’t yet have it, download it here).

At the end of this post, we will complete with a BDC model project which has a “Customer” entity connects to “Customer” table in “Northwind” database, and have CRUD operations enabled. The finished project can also be downloaded from here.

Prepare the data source

If you already have a “Northwind” database, you can skip this section. Otherwise, please download SharePoint2010_BDCSamples.zip from here and extract the SQL script file CreateSampleNorthwindDB.sql.

Open Visual Studio. Go to View->Server Explorer. Right click Data Connections in Server Explorer, and select Create New SQL Server Database.

1. In the prompt dialog, type “localhost\sqlexpress” in Server Name text box, and give the new database name “SampleNorthwind”.

* If you're using the SQL Express that comes with SharePoint Server, please replace “localhost\sqlexpress" with "localhost\sharepoint”.

2. Start a Command Prompt. Go to Start->Run, type “Cmd” in the text box and click OK.

3. In the Command Prompt, type in following command and press enter:

sqlcmd -S localhost\sqlexpress -d samplenorthwind -i <Path of CreateSampleNorthwindDB.sql file>

Create BDC Project

Create a new C# BDC Model project and rename it “BdcSampleCSharp”. VB code snippets will also be provided, so you can create VB BDC Model project if you want. In this walkthrough, we will use C# project as an example. (Check this blog for how to create a BDC project)

Connect to external data source

To use the SampleNorthWind database, we add a LINQ to SQL model to the project:

1. On the Project menu, click Add New Item, in the prompt Add New Item dialog select Data in the Installed Templates pane, in the Templates pane select LINQ to SQL Classes, in the Name box, type “Customer”, and then click Add.

2. In the Server Explorer, go to Data Connections->[hostname]\sqlexpress.SampleNorthWind.dbo->Tables->Customers, drag the Customers table and drop it on the Customer.dbml design surface.

3. Add a new class file and rename it “CustomerDataContext.cs”. Replace the code of the class with the following code snippet.

Note: We made the connection string a constant in the code only for demo purpose, if you’re using your own database, modify the connection string as needed. In our future post we will introduce how to set the connection string in a custom property on LobSystemInstance inside the BDC model and read the value through IContextProperty interface at runtime.

C#:

public partial class CustomerDataContext { private const string ConnectionString = @"Data Source=localhost\SQLEXPRESS;Initial Catalog=SampleNorthwind;Integrated Security=True;Pooling=False"; public CustomerDataContext() : base(ConnectionString, mappingSource) { OnCreated(); } } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; }

VB:

Partial Public Class CustomerDataContext Private Const ConnectionString As String = "Data Source=localhost\SQLEXPRESS;Initial Catalog=SampleNorthwind;Integrated Security=True;Pooling=False" Public Sub New() MyBase.New(ConnectionString, mappingSource) OnCreated() End Sub End Class .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; }

Design BDC Model

1. On the design surface, delete entity Entity1 which is created by default. On the View menu, click on Toolbox if it is not shown. Create a new entity by drag and drop the Entity icon from Toolbox onto design surface (see the screenshot below). In the Properties Browser, change the value of Entity’s Name property to “Customer”.

2. Create a new Identifier CustomerID on entity Customer. To do so, on the design surface, right click the entity, click Add->Identifier. A new identifier appears on the entity, and then rename it to “CustomerID”.

3. Create a Specific Finder method for the entity. To do so, on the design surface, select entity Customer, you could find a <Add a Method> command in the Method Details Window. If the Method Details Window is not opened, you can find it in menu View->Other Windows->BDC Method Details. From the <Add a Method> drop-down list, select Create Specific Finder Method:

A method named ReadItem appears on entity Customer. In the Method Details Window, you will find that the method takes a In parameter and a Return parameter. In the next step we will define TypeDescriptors associated with these parameters.

4. Add TypeDescriptors for the return parameter Customer. The edit need to be done in BDC Explorer. You can find it by going to View->Other Windows->BDC Explorer.

a) In the Method Details Window, click <Edit> command in the drop down control from TypeDescriptor Customer as depicted below. After the click the BDC Explorer will get focused on the TypeDescriptor Customer.

b) In BDC Explorer right click the focused TypeDescriptor Customer and select Add Type Descriptor:

A new TypeDescriptor is created under TypeDescriptor Customer. In the Properties Browser, rename it to “CustomerID”. Next you need to set the Identifier property to “CustomerID” to tell the BCS runtime which identifier this TypeDescriptor represents. Here is a screenshot of Properties Browser after this step:

c) Continue to add following TypeDescriptors under Customer by repeating the operation described above: Address, City, CompanyName, ContactName, Country, Fax, Phone, PostalCode and Region, for each TypeDescriptor, you need to change its Type Name to make sure they match the type defined in the LINQ to SQL model. In this example, all the TypeDesriptors have a type of System.String which is the default one so we do not need to change them. After this step, we get the following TypeDescriptors in BDC Explorer:

d) Next we need to define the actual type of the TypeDescriptor Customer. Click TypeDescriptor Customer in BDC Explorer. You will find in the Properties Browser the value of Type Name property is System.String by default, we need to change it to “BdcSampleCSharp.Customer, BdcModel1” which is a LobSystem qualified type name. This specifies the actual the data type of the data structure that is represented by this TypeDescriptor Customer.

5. Create the other types of methods by the same way described in step 6. After this step we will have five methods in the entity Customer: ReadItem, ReadList, Create, Update and Delete. If you check the ReadList method in Method Details Window, the TypeDescriptors of the return parameter have already been defined with the same structure as we just built above. This is because when creating a new method, BDC designer will search the possible TypeDescriptors defined in the other methods of this entity and copy them to the newly created methods. This saves the developers so much time to define them repetitively.

Add code behind to access external data source

Now it’s time to add code to implement the CRUD functions. In Solution Explorer, find and open CustomerService.cs, and then replace the implementation with the following code snippet:

C#:

public static Customer ReadItem(string customerID) { CustomerDataContext context = new CustomerDataContext(); Customer cust = context.Customers.Single(c => c.CustomerID == customerID); return cust; } public static IEnumerable<Customer> ReadList() { CustomerDataContext context = new CustomerDataContext(); IEnumerable<Customer> custList = context.Customers; return custList; } public static Customer Create(Customer newCustomer) { CustomerDataContext context = new CustomerDataContext(); context.Customers.InsertOnSubmit(newCustomer); context.SubmitChanges(); Customer cust = context.Customers.Single(c => c.CustomerID == newCustomer.CustomerID); return cust; } public static void Delete(string customerID) { CustomerDataContext context = new CustomerDataContext(); Customer cust = context.Customers.Single(c => c.CustomerID == customerID); context.Customers.DeleteOnSubmit(cust); context.SubmitChanges(); } public static void Update(Customer customer, string customerID) { CustomerDataContext context = new CustomerDataContext(); Customer cust = context.Customers.Single(c => c.CustomerID == customer.CustomerID); cust.CustomerID = customer.CustomerID; cust.Address = customer.Address; cust.City = customer.City; cust.CompanyName = customer.CompanyName; cust.ContactName = customer.ContactName; cust.ContactTitle = customer.ContactTitle; cust.Country = customer.Country; cust.Fax = customer.Fax; cust.Phone = customer.Phone; cust.PostalCode =customer.PostalCode; cust.Region = customer.Region; context.SubmitChanges(); } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; }

VB:

Public Shared Function ReadItem(ByVal customerID As String) As Customer Dim context As New CustomerDataContext Dim cust = (From c In context.Customers _ Where c.CustomerID = customerID _ Select c).Single() Return cust End Function Public Shared Function ReadList() As IEnumerable(Of Customer) Dim context As New CustomerDataContext Return context.Customers End Function Public Shared Function Create(ByVal newCustomer As Customer) As Customer Dim context As New CustomerDataContext context.Customers.InsertOnSubmit(newCustomer) context.SubmitChanges() Dim cust = (From c In context.Customers _ Where c.CustomerID = newCustomer.CustomerID _ Select c).Single() Return cust End Function Public Shared Sub Delete(ByVal customerID As String) Dim context As New CustomerDataContext Dim cust = (From c In context.Customers _ Where c.CustomerID = customerID _ Select c).Single() context.Customers.DeleteOnSubmit(cust) context.SubmitChanges() End Sub Public Shared Sub Update(ByVal customer As Customer, ByVal customerID As String) Dim context As New CustomerDataContext Dim cust = (From c In context.Customers _ Where c.CustomerID = customer.CustomerID _ Select c).Single() cust.Address = customer.Address cust.City = customer.City cust.CompanyName = customer.CompanyName cust.ContactName = customer.ContactName cust.ContactTitle = customer.ContactTitle cust.Country = customer.Country cust.Fax = customer.Fax cust.Phone = customer.Phone cust.PostalCode = customer.PostalCode cust.Region = customer.Region context.SubmitChanges() End Sub .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; }

Create an external list to test out the BDC Model!

Now we are done! Let’s deploy the solution and create an external list to test it out (Check this blog to see how to create an external list). After the list is created, you will see the following page appears when you click on the list name:

All the data are pulled out to SharePoint successfully, now you can create, delete or edit customer records.

To create a new Customer, find the List Tools->Items->New Item button on the ribbon shown in the following screenshot:

Click on the button, New Item dialog will pop out as below:

Fill in the dialog and click Save, you will find the item created in the list right away.

To edit or delete the item, just click the down arrow at the right side of CustomerID, all the operations you need are there.

FalconStor and startup Violin Memory partner on a SAN acceleration device that uses Flash solid-state drives (SSDs) and FalconStor software to speed write performance.

In this essential guide, learn about the best options and the latest trends in storage networking for SMBs. Download it for free.

Storwize's compression appliances, which sit inline in front of primary network attached storage, can now be paired for HA and compress existing data on legacy systems.

SharePoint web dialogs bring an exciting new UI feature: they can auto-size to the content of a hosted page. Auto-sizing works by examining the contents of your page during page load, and setting the size of the dialog accordingly. Unfortunately, this feature can be speed bump on the road to master page customization. This post will describe the master page customization process necessary to keep dialog auto-sizing working with your master pages.

 

The most important thing to note is that the auto-sizing feature is aware of whether the ribbon is fixed at the top of the screen. It is important to know whether your master page has the ribbon fixed at the top of the screen or not in order to customize it to work well with auto-sizing. A ribbon fixed on top of the screen looks like this, with the page content below the ribbon scrollable separately from the ribbon itself:

 

If the ribbon is fixed at the top of the screen, be sure the following statements about your master page are true:

• The ribbon is inside an element with ID "s4-ribbonrow".
• The remaining page content is inside an element with ID "s4-workspace".
• The element with ID "s4-workspace" is scrollable.
• The <body> element is not scrollable.

If the ribbon is not fixed at the top of the screen, be sure the following statements about your master page are true:

• There is no element on the page with ID "s4-ribbonrow".
• The <body> element is scrollable.

The auto-sizing process happens when the hosted page loads. If your master page or any individual pages use dynamic HTML to change the size, position, or amount of content on the page after page load, you may need to re-invoke the auto-sizing process after the dynamic content update in order to obtain a correctly-sized dialog. From within a hosted page, call

window.frameElement.autoSize();

to invoke the auto-sizing process. During initial page load, the dialog is hidden and a loading dialog is shown (see below). However, after the page has loaded, re-invoking the auto-sizing process will continue to show the existing dialog while changing its size.

 

 

If your master page uses a table-based layout, or a variable-width layout, the auto-sizing process may be unable to determine the correct size. In that case, you can try to set a minimum or fixed width on an element in the page in order to help the auto-sizing process.

Zach Nation

Software Developer on SharePoint Foundation

Although the H1N1 virus hasn't hit the United States as hard as expected, there were many lessons learned for disaster recovery (DR) and business continuity (BC) planners.

Iomega's desktop network-attached storage (NAS) systems traveled with the U.S. Olympic team to Vancouver to provide networked data storage, file and print and digital signage services.

Hi all.  This is Greg Chan, Program Manager on the SharePoint team, for the third part in this List View series. In this post I’m excited to have one of the key architects of the new XSLT List View Web Part (XLV) talk more about its architecture.  Here is what he has to say:

Hi! I’m Eric Andeen, a developer on the SharePoint team. I’m going to describe in a little more detail how the XSLT List View Web Part (XLV) works, and how that affects people building and using SharePoint sites.

List View XML and minimal markup

As Greg mentioned in Part I, the XLV is the new list view technology in SharePoint 2010, replacing the List View Web Part (LVWP). Since the XLV is the replacement for the LVWP, it needs to do all the same things, as well as adding new capabilities. The best place to start this discussion is with some of the things that haven’t changed.

The markup required to specify a LVWP is pretty simple – we need to know which list the LVWP is displaying, and we need to know about the view. The list can be identified by name, URL or guid identifier, but the view is a little more complex, and is specified in XML. This is an example of the ViewXML of the default view of an announcements list:

<View Name="{F5D7FCD1-BEFE-42b5-9339-4F4F3C6A38FE}" DefaultView="TRUE" DisplayName="All Items" Url="/Lists/Announcements/AllItems.aspx">

  <Query>

    <OrderBy>

      <FieldRef Name="Modified" Ascending="FALSE"/>

    </OrderBy>

  </Query>

  <ViewFields>

    <FieldRef Name="Attachments"/>

    <FieldRef Name="LinkTitle"/>

    <FieldRef Name="Modified"/>

    <FieldRef Name="Number"/>

  </ViewFields>

  <RowLimit Paged="TRUE">30</RowLimit>

</View>

 

The primary use of the ViewXML is to generate the SPDataSource that gets the data, but it is also used in the xsl transform to turn the raw xml data returned into presentable HTML, as we will see below. The part of the ViewXML that’s most important to this discussion is the <ViewFields> tag – it tells SharePoint which fields are in the view.

Schema Independent XSL

The XLV is now the default list view technology in SharePoint, and that means it has to scale as well as the LVWP. The only way that’s possible is for the XLV to render any uncustomized, out of the box view using a single XSLT. An uncustomized XLV has no <xsl> property at all – SharePoint supplies the same shared XSLT that is used to render every other XLV. The XSLT responsible for this lives on your server at http://<myserver>/_layouts/xsl/main.xsl – go ahead and open it up and look at it, as well as the xsl:import files vwstyles.xsl and fldtypes.xsl that do most of the work.

Before we discuss how the XLV’s schema independent XSLT works, it’s worth considering how typical, schema dependent XSLT like that used in the DataFormWebPart works. In order to render a tabular view of rows and columns, any technology, XSLT included, needs to iterate through the rows, and in each row, it needs to iterate through the columns, rendering each part appropriately. The XML we’re transforming looks like this:

<Rows>

  <Row @Field1="Hello" @Field2="World!" @Field3=""      />

  <Row @Field1="Some"  @Field2="More"   @Field3="Data"  />

  <Row @Field1="Yet"   @Field2="More"   @Field3="Data"  />

</Rows>

 

The interesting portion of a typical XSLT for this XML looks like this:

<xsl:for-each select="$Rows">

  <tr>

    <td>

      <xsl:value-of select="@Field1"/>

    </td>

    <td>

      <xsl:value-of select="@Field2"/>

    </td>

    <td>

      <xsl:value-of select="@Field3"/>

    </td>

  </tr>

</xsl:for-each>

The output HTML is a 3x3 table:

Hello

World!

 

Some

More

Data

Yet

More

Data

This XSLT is schema dependent because it iterates through the list of columns by naming each one explicitly. Using this XSLT, the schema of the rendered list is fixed; it’s not possible to change the set of fields without changing the XSLT.

The schema independent XSLT that the XLV uses iterates through the rows pretty much the same way as the example above, but it iterates through the columns quite differently. When the XLV renders the list, the XML passed in to the transformation engine includes not just the data in the <Rows> collection; it also includes the ViewXML shown above, enhanced with additional schema information. There are several instances of the field iterator in the XSLT to accommodate different view styles, but they all look something like this:

<xsl:for-each select="ViewFields/FieldRef">

  <xsl:apply-templates mode="PrintField" select=".">

    <xsl:with-param name="thisNode" select="$thisNode"/>

  </xsl:apply-templates>

</xsl:for-each>

The “ViewFields" referenced in the <xsl:for-each> is the <ViewFields> tag in the enhanced ViewXML markup, and the $thisNode variable refers to the current row in the Rows collection. The XSLT also contains a set of templates for rendering the fields. A simplified version of those field templates would look like this:

<xsl:template match="FieldRef" mode="PrintField">

  <xsl:param name="thisNode" select="."/>

  <td>

    <xsl:apply-templates match="FieldRef" mode="PrintValue">

      <xsl:with-param name="thisNode" select="$thisNode"/>

    </xsl:apply-templates>

  </td>

</xsl:template>

 

<xsl:template match="FieldRef" mode="PrintValue>"

  <xsl:param name="thisNode" select="."/>

  <xsl:value-of select="$thisNode/@*[name()=current()/@Name]"/>

</xsl:template>

 

The first template outputs the <td> tag and then calls the next template to output the actual value. The second template is where things get interesting. In the schema dependent example above, the values were all named explicitly – @Field1, etc. We can’t do that in the schema independent XSLT, so instead, we use the FieldRef node in the ViewFields markup to get the appropriate attribute from the row. $thisNode is the row of data we’re looking at, and the current XSLT context (.) is the FieldRef node for the field we’re rendering. So the value of the funky xpath expression above – $thisNode/@*[name()=current()/@Name] – is the value of the attribute in the Row tag for the current field – exactly what we want. $thisNode is the row of data we're looking it; @* is the xpath attribute axis, and [name()=current()/@Name] selects the one attribute whose name matches the @Name attribute of the current context – the FieldRef node.

The actual XSLT for the XLV has to do more than just render simple values inside unadorned <td> tags – it has to render field headers, list item menus on title fields, proper CSS classes on <td> and other tags, etc. It also has to render some field types (hyperlink, person, etc.) differently from simple text fields. All this is done through the same basic mechanism as in the simplified version above – the fields iterator calls a template to render the field, which in turn calls into a series of other templates. Some of the simpler differences make use of <xsl:apply-templates> to select the right template – the template that renders date fields has a match="FieldRef[@Type='DateTime']" instead of just match="FieldRef", for example. More complex checks make use of <xsl:if> and <xsl:choose> along with <xsl:call-template> to call the right template.

XLV Model

The following diagram sums up the process which turns list data and XSLT into the view you see when you browse to a SharePoint page. The data comes from an SPDataSource control, but unlike the DataFormWebPart, the SPDataSource control is dynamically generated from the ViewXML in the diagram below. The SPDataSource control produces an XML rowset containing the list data. The ViewXML gets enhanced with list schema information and added to the XML rowset containing the data. The XSLT is compiled into an XslCompiledTransform – and since we always use the same XSLT, it's only compiled once per web server. The XML rowset, with both the data and the enhanced ViewXML, is passed into the XslCompiledTransform, and the HTML output goes into the page stream and onto the screen of your browser.

Modifying the View

One of the benefits of this approach is that we can now change the set of fields in the view, and the XSLT will still render them properly. Want to add Field4 to the data? No problem – just add it to the ViewXML. Want to change Field1 from a simple text field to a person field? No problem – just change the field definition in SharePoint, and the enhanced ViewXML markup has the new type, so the field will render properly as the new type.

What if we want to make more complex changes to the XSLT – things like conditional formatting? It's possible to do so in SharePoint designer, generally without losing the advantages of the schema independent XSLT. We'll cover that in depth in the next post in this series.

Performance

Although the ability to modify the view without changing the XSLT is a very nice benefit of the schema independent XSLT, it's not the most important one. The primary benefit, and the one that allows the XLV to become the default view technology, is performance and scalability. The SharePoint server loads one copy of the XSLT into memory and reuses it for every uncustomized XLV it renders, which allows the server to render many views very quickly. And the lack of a large <xsl> property on uncustomized views means that each view takes only a small amount of space in the content database, which allows a site collection to contain a large number of lists and views without space issues.

This week's data backup and recovery news in brief: Bus-Tech Inc. announces version 7 of its Mainframe Data Library; SugarSync launches new email synching feature and more.

With SGI acquiring MAID-maker Copan Systems at a clearance price, customers hope to see Copan disk arrays get a performance improvement, as well as easier and cheaper upgrades.

This week's SMB data storage news in brief: Tandberg Data introduces new NAS series; Nimbus Technology launches new cloud storage service and more.

Frank Slootman, the head of EMC's backup division, discusses EMC's data backup and global data deduplication plans.

Iron Mountain makes a big move into on-premise enterprise data archiving software with acquisition of Mimosa Systems; doesn't want to wait for big enterprises to move more data to the cloud.

Double-Take lets customers of its backup and replication software tie into Amazon Elastic Computer Cloud (EC2) cloud for disaster recovery without needing a second data center.