Canonical Voices

Posts tagged with 'ubuntuone'

Roberta Nilerud

In late 2011 Vodafone launched their boutique app store for Android named Vodafone AppSelect. The store is available across Europe and takes the hassle out of searching.

We can finally announce that our hugely popular Ubuntu One Files app has been selected by Vodafone for their curated app store. It’s now available to download via the Vodafone store in the UK, Ireland, Germany, Russia, Italy, Greece and Portugal.

U1 Files app is free and it includes 5GB of cloud storage. Users tell us they love the seemingly magic way U1 Files automatically sends photos taken from their phones directly to their personal cloud and other devices. So snap away, and forget about uploading, sending or tethering to other devices – Ubuntu One takes care of that for you.

The benefit of this feature hit home recently when my SD card decided to die with no warning – a year’s worth of photos and important moments I’d captured were gone. Or so I thought….I remembered that the clever Ubuntu One Files app had been working hard in the background during that time, seamlessly sending my photos back to U1 and onto my home PC. I can’t tell you the massive sense of relief I got from logging in and seeing all my photos safe and available for me to share.

Ubuntu One is available on several operating systems: Windows, Android, iOS and of course, Ubuntu. But remember, while using Ubuntu as your OS is a fantastic experience – you don’t need to use Ubuntu to reap the benefits of Ubuntu One.

Read more
Roberta Nilerud

An important note about Notes

We want to let you know that on Tuesday, February 28th we will be removing Notes from the Ubuntu One web interface. The reason for this is that the U1 Notes web interface hasn’t really been working as well as we want it to. We have looked at the improvements required and the resources needed to raise the overall quality of the notes web interface. However, with everything that we have to work on in 2012, plus continuing to improve our core services, we just won’t be able to give it the attention it needs.

For those of you syncing notes with Ubuntu One, this means you’ll continue to sync them via Tomboy just as you do today. The only difference is that you won’t be able to access these notes via the Ubuntu One web site after February 27th. If you have any more questions around U1 Notes please contact us.

Meanwhile, we’re continuing to build a new higher quality data sync service that will benefit notes as well as other types of data. This service will provide a solid foundation for our own data sync services as well as those of app developers. We’ll continue to post updates about that exciting development as we have more news.

Read more
Roberta Nilerud

Kicking off 2012 with iOS Files and CES

As the dust settles from the holidays the U1 team is kicking off the new year with our first release of 2012.  Our eagerly anticipated Files app for iOS is now ready for download in the app store.

The Android version of this app has been hugely successful and the iOS version delivers to the same high standard, so you can secure and manage your photos and files directly from your iOS device wherever you are.

One great feature of the Ubuntu One Files app is that each time you open it, it will automatically send photos snapped on your iOS device directly to your Ubuntu One personal cloud and other connected devices. So you’ll have peace of mind knowing all your precious photos are backed up to your Ubuntu One cloud instantly. Sharing photos with family, friends and to social spaces from the app is also made easy and you can post straight to Facebook, Twitter, Google+ or your blog. This is a free app so all you have to do to get started is install the app and login to your Ubuntu One account. If you are new to Ubuntu One simply register for a free account and get 5GB of free cloud storage.

 

More good news is that for the first time we will be at CES this year in Las Vegas from 10-13th of January. Ubuntu One will be showcased alongside the Ubuntu OS, so if you are heading to CES come by and see us at the Ubuntu booth located on the upper level South Hall 4, #35379 . Some members of the Ubuntu One team will be on hand to demonstrate all the great things Ubuntu One can do and to answer any questions you may have. There will also be some U1 goodies to take home. Along with all our file sync and mobile music streaming services, the recently launched Web Music Streaming and the new Files app for iOS will be available to demo, as well as an exclusive sneak peak at the future evolution of Ubuntu One. Exciting times lie ahead as we will continue to lead the way in linking the personal cloud with consumer electronics by being first to bring the convenience of the Ubuntu One personal cloud to the connected car. We have partnered with several auto electronic engineering suppliers to create a prototype of the Ubuntu One connect car. The first iteration will focus on music streaming with major auto suppliers Visteon and Delphi at CES showcasing their take on music streaming from your Ubuntu One personal cloud to your car.

In addition, embedded systems software developer AllGo Systems will show Ubuntu One music streaming integrated into their automotive middleware. Plus, semiconductor producer Freescale will demonstrate Ubuntu One music streaming on their ARM i.MX platform.

All in all it’s a busy start to the year for us and in 2012 we are looking to continue the same fast pace we set in 2011. Throughout this year we will be working hard to further enhance performance of current services and introduce more great features for our loyal users to enjoy. We also aim to bring Ubuntu One to new audiences so even more people around the world can share the Ubuntu One personal cloud experience.

Read more
mandel

In the past days I have been working on implementing a python TestCase that can be used to perform integration tests to the future implementation of proxy support that will be landing in Ubuntu One. The idea of the TestCase is the following:

  • Start a proxy so that connections go throw it. The proxy has to be listening to two different ports, one in which auth is not required and a second one in which auth is required. At the moment the only supported proxy is Squid using base auth.
  • The test case should provide a way to access to the proxy details for subclasses to use.
  • The test case should integrate with the ubuntuone-dev-tools.

Initially, one of the major problems I had was to start squid in two different ports so that:

  • Port A accepts non-auth requests.
  • Port A rejects auth requests.
  • Port B accepts auth requests.

The idea is simple, if you use port A you should never auth while you must in port B, and example configuration of the ACLs and ports is the following:

auth_param basic casesensitive on
# Use a default auth using ncsa and the passed generated file.
auth_param basic program ${auth_process} ${auth_file}
#Recommended minimum configuration:
acl all src all
acl manager proto cache_object
acl localhost src 127.0.0.1/32
acl to_localhost dst 127.0.0.0/8 0.0.0.0/32
#
# Example rule allowing access from your local networks.
# Adapt to list your (internal) IP networks from where browsing
# should be allowed
acl localnet src 10.0.0.0/8	# RFC1918 possible internal network
acl localnet src 172.16.0.0/12	# RFC1918 possible internal network
acl localnet src 192.168.0.0/16	# RFC1918 possible internal network
#
acl SSL_ports port 443		# https
acl SSL_ports port 563		# snews
acl SSL_ports port 873		# rsync
acl Safe_ports port 80		# http
acl Safe_ports port 21		# ftp
acl Safe_ports port 443		# https
acl Safe_ports port 70		# gopher
acl Safe_ports port 210		# wais
acl Safe_ports port 1025-65535	# unregistered ports
acl Safe_ports port 280		# http-mgmt
acl Safe_ports port 488		# gss-http
acl Safe_ports port 591		# filemaker
acl Safe_ports port 777		# multiling http
acl Safe_ports port 631		# cups
acl Safe_ports port 873		# rsync
acl Safe_ports port 901		# SWAT
acl purge method PURGE
acl CONNECT method CONNECT

# make an acl for users that have auth
acl password proxy_auth REQUIRED myportname ${auth_port_number}
acl auth_port_connected myportname ${auth_port_number}
acl nonauth_port_connected myportname ${noauth_port_number}

# Settings used for the tests:
# Allow users connected to the nonauth port
# Allow users authenticated AND connected to the auth port
http_access allow nonauth_port_connected
http_access allow password

#Recommended minimum configuration:
#
# Only allow cachemgr access from localhost
http_access allow manager localhost
http_access deny manager
# Only allow purge requests from localhost
http_access allow purge localhost
http_access deny purge
# Deny requests to unknown ports
http_access deny !Safe_ports
# Deny CONNECT to other than SSL ports
http_access deny CONNECT !SSL_ports
# Example rule allowing access from your local networks.
# Adapt localnet in the ACL section to list your (internal) IP networks
# from where browsing should be allowed
#http_access allow localnet
http_access allow localhost

# And finally deny all other access to this proxy
http_access deny all

#Allow ICP queries from local networks only
icp_access allow localnet
icp_access deny all

# Squid normally listens to port 3128 but we are going to listento two
# different ports, one for auth one for nonauth.
http_port ${noauth_port_number}
http_port ${auth_port_number}

#We recommend you to use at least the following line.
hierarchy_stoplist cgi-bin ?

# Default cache settings.
cache_dir ufs ${spool_temp} 100 16 256

# access log settings
access_log ${squid_temp}/access.log squid

#Default cache stroe log
cache_store_log ${squid_temp}/store.log

#Default pid file name
pid_filename ${squid_temp}/squid.pid

#Default netdb file name:
netdb_filename ${spool_temp}/logs/netdb.state

#Suggested default:
refresh_pattern ^ftp:		1440	20%	10080
refresh_pattern ^gopher:	1440	0%	1440
refresh_pattern -i (/cgi-bin/|\?) 0	0%	0
refresh_pattern (Release|Packages(.gz)*)$	0	20%	2880
# example line deb packages
#refresh_pattern (\.deb|\.udeb)$   129600 100% 129600
refresh_pattern .		0	20%	4320

# Don't upgrade ShoutCast responses to HTTP
acl shoutcast rep_header X-HTTP09-First-Line ^ICY.[0-9]
upgrade_http0.9 deny shoutcast

# Apache mod_gzip and mod_deflate known to be broken so don't trust
# Apache to signal ETag correctly on such responses
acl apache rep_header Server ^Apache
broken_vary_encoding allow apache

extension_methods REPORT MERGE MKACTIVITY CHECKOUT

hosts_file /etc/hosts

# Leave coredumps in the first cache dir
coredump_dir ${spool_temp}

Once the above was achieved the code of the test case was quite simple for Ubuntu O, unfortunatly, it was not that issues in Ubuntu P because there we have squid3 which supports http 1.1 and keeps the proxy keeps the connection alive. The fact that the connection is kept alive means that the reactor has a selectable running because the proxy keep it there. In order to solve the issue I wrote the code so that the server could say that the connection timedout. Here is the code that does it:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
# -*- coding: utf-8 -*-
#
# Copyright 2011 Canonical Ltd.
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License version 3, as published
# by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranties of
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
# PURPOSE.  See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program.  If not, see <http://www.gnu.org/licenses/>.
"""Test the squid test case."""
import base64
 
from twisted.application import internet, service
from twisted.internet import defer, reactor
from twisted.web import client, error, http, resource, server
 
from ubuntuone.devtools.testcases.squid import SquidTestCase
 
 
SAMPLE_RESOURCE = "<p>Hello World!</p>"
SIMPLERESOURCE = "simpleresource"
THROWERROR = "throwerror"
UNAUTHORIZED = "unauthorized"
 
# ignore common twisted lint errors
# pylint: disable=C0103, W0212
 
 
class ProxyClientFactory(client.HTTPClientFactory):
    """Factory that supports proxy."""
 
    def __init__(self, proxy_url, proxy_port, url, headers=None):
        # we set the proxy details before the init because the parent __init__
        # calls setURL
        self.proxy_url = proxy_url
        self.proxy_port = proxy_port
        self.disconnected_d = defer.Deferred()
        client.HTTPClientFactory.__init__(self, url, headers=headers)
 
    def setURL(self, url):
        self.host = self.proxy_url
        self.port = self.proxy_port
        self.url = url
        self.path = url
 
    def clientConnectionLost(self, connector, reason, reconnecting=0):
        """Connection lost."""
        self.disconnected_d.callback(self)
 
 
class ProxyWebClient(object):
    """Provide useful web methods with proxy."""
 
    def __init__(self, proxy_url=None, proxy_port=None, username=None,
            password=None):
        """Create a new instance with the proxy settings."""
        self.proxy_url = proxy_url
        self.proxy_port = proxy_port
        self.username = username
        self.password = password
        self.factory = None
        self.connectors = []
 
    def _connect(self, url, contextFactory):
        """Perform the connection."""
        scheme, _, _, _ = client._parse(url)
        # pylint: disable=E1101
        if scheme == 'https':
            from twisted.internet import ssl
            if contextFactory is None:
                contextFactory = ssl.ClientContextFactory()
            self.connectors.append(reactor.connectSSL(self.proxy_url,
                                                      self.proxy_port,
                                                      self.factory,
                                                      contextFactory))
        else:
            self.connectors.append(reactor.connectTCP(self.proxy_url,
                                                      self.proxy_port,
                                                      self.factory))
            # pylint: enable=E1101
 
    def _process_auth_error(self, failure, url, contextFactory):
        """Process an auth failure."""
        failure.trap(error.Error)
        if failure.value.status == str(http.PROXY_AUTH_REQUIRED):
            # we try to get the page using the basic auth
            auth = base64.b64encode('%s:%s' % (self.username, self.password))
            auth_header = 'Basic ' + auth.strip()
            self.factory = ProxyClientFactory(self.proxy_url, self.proxy_port,
                            url, headers={'Proxy-Authorization': auth_header})
            self._connect(url, contextFactory)
            return self.factory.deferred
        else:
            return failure
 
    def get_page(self, url, contextFactory=None, *args, **kwargs):
        """Download a webpage as a string.
 
        This method relies on the twisted.web.client.getPage but adds and extra
        step. If there is an auth error the method will perform a second try
        so that the username and password are used.
        """
        self.factory = ProxyClientFactory(self.proxy_url, self.proxy_port, url,
                                          headers={'Connection': 'close'})
        self._connect(url, contextFactory)
        self.factory.deferred.addErrback(self._process_auth_error, url,
                                    contextFactory)
        return self.factory.deferred
 
    @defer.inlineCallbacks
    def shutdown(self):
        """Clean all connectors."""
        for connector in self.connectors:
            yield connector.disconnect()
        defer.returnValue(True)
 
 
class SimpleResource(resource.Resource):
    """A simple web resource."""
 
    def render_GET(self, request):
        """Make a bit of html out of these resource's
        content."""
        return SAMPLE_RESOURCE
 
 
class SaveHTTPChannel(http.HTTPChannel):
    """A save protocol to be used in tests."""
 
    protocolInstance = None
 
    def connectionMade(self):
        """Keep track of the given protocol."""
        SaveHTTPChannel.protocolInstance = self
        http.HTTPChannel.connectionMade(self)
 
 
class SaveSite(server.Site):
    """A site that let us know when it closed."""
 
    protocol = SaveHTTPChannel
 
    def __init__(self, *args, **kwargs):
        """Create a new instance."""
        server.Site.__init__(self, *args, **kwargs)
        # we disable the timeout in the tests, we will deal with it manually.
        self.timeOut = None
 
 
class MockWebServer(object):
    """A mock webserver for testing"""
 
    def __init__(self):
        """Start up this instance."""
        root = resource.Resource()
        root.putChild(SIMPLERESOURCE, SimpleResource())
 
        root.putChild(THROWERROR, resource.NoResource())
 
        unauthorized_resource = resource.ErrorPage(resource.http.UNAUTHORIZED,
                                                "Unauthorized", "Unauthorized")
        root.putChild(UNAUTHORIZED, unauthorized_resource)
 
        self.site = SaveSite(root)
        application = service.Application('web')
        self.service_collection = service.IServiceCollection(application)
        #pylint: disable=E1101
        self.tcpserver = internet.TCPServer(0, self.site)
        self.tcpserver.setServiceParent(self.service_collection)
        self.service_collection.startService()
 
    def get_url(self):
        """Build the url for this mock server."""
        #pylint: disable=W0212
        port_num = self.tcpserver._port.getHost().port
        return "http://localhost:%d/" % port_num
 
    @defer.inlineCallbacks
    def stop(self):
        """Shut it down."""
        #pylint: disable=E1101
        # make the connection time out so that is works with squid3 when
        # the connection is kept alive.
        if self.site.protocol.protocolInstance:
            self.site.protocol.protocolInstance.timeoutConnection()
        yield self.service_collection.stopService()
 
 
class ProxyTestCase(SquidTestCase):
    """A squid test with no auth proxy."""
 
    @defer.inlineCallbacks
    def setUp(self):
        """Set the tests."""
        yield super(ProxyTestCase, self).setUp()
        self.ws = MockWebServer()
        self.proxy_client = None
        self.addCleanup(self.teardown_client_server)
        self.url = self.ws.get_url() + SIMPLERESOURCE
 
    def teardown_client_server(self):
        """Clean resources."""
        if self.proxy_client is not None:
            self.proxy_client.shutdown()
            return defer.gatherResults([self.ws.stop(),
                               self.proxy_client.shutdown(),
                               self.proxy_client.factory.disconnected_d])
        else:
            return self.ws.stop()
 
    def access_noauth_url(self, address, port):
        """Access a url throught the proxy."""
        self.proxy_client = ProxyWebClient(proxy_url=address, proxy_port=port)
        return self.proxy_client.get_page(self.url)
 
    def access_auth_url(self, address, port, username, password):
        """Access a url throught the proxy."""
        self.proxy_client = ProxyWebClient(proxy_url=address, proxy_port=port,
                                         username=username, password=password)
        return self.proxy_client.get_page(self.url)
 
    @defer.inlineCallbacks
    def test_noauth_url_access(self):
        """Test accessing to the url."""
        settings = self.get_nonauth_proxy_settings()
        # if there is an exception we fail.
        data = yield self.access_noauth_url(settings['host'],
                                            settings['port'])
        self.assertEqual(SAMPLE_RESOURCE, data)
 
    @defer.inlineCallbacks
    def test_auth_url_access(self):
        """Test accessing to the url."""
        settings = self.get_auth_proxy_settings()
        # if there is an exception we fail.
        data = yield self.access_auth_url(settings['host'],
                                          settings['port'],
                                          settings['username'],
                                          settings['password'])
        self.assertEqual(SAMPLE_RESOURCE, data)
 
    def test_auth_url_401(self):
        """Test failing accessing the url."""
        settings = self.get_auth_proxy_settings()
        # swap password for username to fail
        d = self.failUnlessFailure(self.access_auth_url(settings['host'],
                                        settings['port'], settings['password'],
                                        settings['username']), error.Error)
        return d
 
    def test_auth_url_407(self):
        """Test failing accessing the url."""
        settings = self.get_auth_proxy_settings()
        d = self.failUnlessFailure(self.access_noauth_url(settings['host'],
                                   settings['port']), error.Error)
        return d

The above code is the tests for the test case and the important bits are:

133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
class SaveHTTPChannel(http.HTTPChannel):
    """A save protocol to be used in tests."""
 
    protocolInstance = None
 
    def connectionMade(self):
        """Keep track of the given protocol."""
        SaveHTTPChannel.protocolInstance = self
        http.HTTPChannel.connectionMade(self)
 
 
class SaveSite(server.Site):
    """A site that let us know when it closed."""
 
    protocol = SaveHTTPChannel
 
    def __init__(self, *args, **kwargs):
        """Create a new instance."""
        server.Site.__init__(self, *args, **kwargs)
        # we disable the timeout in the tests, we will deal with it manually.
        self.timeOut = None

The above defines a protocol that will know the instance that it was used so that we can trigger the time out in a clean up function.

190
191
        if self.site.protocol.protocolInstance:
            self.site.protocol.protocolInstance.timeoutConnection()

This tells the server to time out.

207
208
209
210
211
212
213
214
215
    def teardown_client_server(self):
        """Clean resources."""
        if self.proxy_client is not None:
            self.proxy_client.shutdown()
            return defer.gatherResults([self.ws.stop(),
                               self.proxy_client.shutdown(),
                               self.proxy_client.factory.disconnected_d])
        else:
            return self.ws.stop()

And the clean up function. That is all, now I guess I’ll move to add proxy support or ensure that the test case works on Windows, which is certainly going to be a diff issue.

Read more
Stuart Langridge

Merry Christmas from the Ubuntu One team! As announced at UDS in Orlando in November, the Ubuntu One team have been working on a project to allow application developers to sync data to Ubuntu One, and we’ve now reached the tech preview stage. Here’s the details.

U1DB is a database API for synchronised databases of JSON documents. It’s simple to use in applications, and allows apps to store documents and synchronise them between machines and devices. U1DB itself is not a database: instead, it’s an API and data model which can be backed by any database for storage. This means that you can use U1DB on different platforms, from different languages, and backed on to different databases, and sync between all of them.

Data sync is an essential part of what we want to offer with Ubuntu One. We already offer file sync, and that’s also part of our developer story (the APIs for file sync and music streaming are documented at https://one.ubuntu.com/developer/); U1DB is designed to offer data sync. Some information in your personal cloud is best done as files: your music, your photos, letters written in Word, things you want to back up. However, applications work with data: contacts, metadata about your files, todo lists, preferences and settings, and most stuff an application works with. We’re building U1DB to allow app developers to work with the same data on every platform and in every language; to save data and sync it between devices without having to manage that themselves.

We’ve been working on U1DB enough to have a working implementation, and now we want to get it out to all of you. We’re calling this a tech preview — it’s a working version of U1DB, with the intention that developers look at it and play with it and start working with it. We’re very interested in hearing your thoughts on the current implementation, the API, and its use in applications. Give us your thoughts in comments here or on the U1DB mailing list at https://launchpad.net/~u1db-discuss or just join us at #u1db on freenode for a chat. The tech preview is of the reference implementation — this is written in (and to be used from) Python on Windows or Ubuntu or anywhere Python runs, and it’s where we work on the algorithms and API used across all U1DB implementations. This tech preview contains the library to work with U1DBs from Python, and an example server and client implementation — U1DB is peer-to-peer syncing, so it’s perfectly possible to run your own server and sync to that, and this tech preview has an example server to play with.

You can see (early) documentation of U1DB, the API, and example usage at http://people.canonical.com/~aquarius/u1db-docs/. We are also working on Vala and JavaScript implementations of U1DB: you can find the Vala implementation at http://launchpad.net/shardbridge, and we plan to build implementations of U1DB for iOS (Obj-C on SQLite) and Android (Java on SQLite) in the future.

The tech preview is mostly about getting input into the product so we can make sure we build something that is useful for people. We also have listed a number of open questions on detailed technical subjects which we’d like to hear opinions on from people who would be interested in using U1DB or writing a new implementation for another platform or language or database backend. Give us your thoughts on these too!

Open Questions

  1. In general, creating an API that is conceptually portable across many languages has some difficulties. For example, currently, the reference implementation provides a Document object, where doc_obj.content is a JSON string of the document content. This means that app developers using the Python API need to json.loads(doc_obj.content) to edit the content of a Document. Should a Document be addressable as a dictionary? This is an obvious thing to do in Python, but it does not necessarily make sense across many platforms; how would you envisage a Document object looking in C? In Java? In Objective C? In your choice of language?
  2. Revision IDs for a U1DB Document are currently quite verbose, but this makes them easy to read (and makes it easier to debug issues). Should we use a less readable but more compact format for these version vectors?
  3. Ubuntu One’s U1DB server will have a direct HTTP API, so that apps can retrieve and store data directly in the cloud without syncing. The HTTP API is also used for syncing U1DBs to Ubuntu One. What form of authorization should be used for this HTTP API, both for syncing and for direct access? Other Ubuntu One services use OAuth 1.1; should we examine OAuth 2, or other alternatives, or is it more important to be able to use the same tokens and auth libraries as other Ubuntu One services?
  4. Indexing is a tricky issue. Letting users provide code to do the indexing is tricky and creating a reasonably thorough DSL is a lot of work. We’re currently taking the DSL route; index expressions are basically a domain-specific language for querying a u1db. Is there a middle ground?
  5. Index expressions can not only name fields but also apply transformation functions to them. For example, lower(fieldname) stores the lowercased contents of a field as an index key, and splitwords(fieldname) splits the contents of the field on whitespace and stores each item as an index key. What are the basic transformation functions we should support? What are the use cases for your proposals? What do apps need?
  6. Each peer in replication has a replica uid, a name for that device. Should those ids be just uuids (as they are currently)? Can we use hostnames? Can we detect a db copied across machines? How about a db copied locally? Is identifying these important?

These questions are the stuff we are discussing currently. Any comments on these or other issues not covered here will be most welcome.

So, to get started, see the quickstart guide at http://people.canonical.com/~aquarius/u1db-docs/, and let us know about your ideas for applications using U1DB and your thoughts on the API!

Read more
Roberta Nilerud

As of today, you can now stream your music stored in Ubuntu One via the web, a great addition to our already popular service for Android and iOS devices. Listen to any song, anywhere on your mobile and now on the web! This latest update comes just in time for the holidays, so you can stream your festive favourites at your work party or family events.

Web music streaming lives in the new Music tab on the U1 dash when you log in to one.ubuntu.com. With song, artist and album views, simple playlist creation, queue management and random play, you’ll be able to listen to your music in your favorite way.

 

If you already have a Music Streaming subscription you’ll instantly be able to access web music streaming. If not, the Ubuntu One Music Streaming subscription comes with 20GB of storage built-in, all for just $3.99 per month or $39.99 per year and you can try it free for 30 days. If you already have an Ubuntu One account, when logged in just follow the ‘Try free for 30days’ upgrade link in the music tab. If you are new to Ubuntu One, first set up a Free account and then add Music Streaming.

 

2011 has been a busy year for the Ubuntu One team with multiple milestone releases. So we’d like to say happy holidays to all our loyal users and thank you for all your support throughout 2011! After a much needed rest over the holidays the team are going to be hard at work again making sure 2012 starts with a bang, so keep your eye on the blog to find out more about Ubuntu One exciting plans in the new year.

Read more
mandel

At the moment we are working on providing support for proxy on Ubuntu One. In order to test this correctly I have been setting up a LAN in my office so that I can test as many scenarion as possible. On of those scenarios is the one in which the auth if the proxy uses Active Directory.

Because I use bind9 to set one of my boxed for the DNS I had to dig out how to configure it to work with AD. In order to do that I did the following:

  1. Edited named.conf.local to add a subdomain for the AD machine:

    zone "ad.example.com" {
            type master;
            file "/etc/bind/db.ad.example.com";
            allow-update { 192.168.1.103; };
    };
    
  2. Configured the subzone to work with AD.

    ; BIND data file for local loopback interface
    ;
    $TTL    604800
    @       IN      SOA     ad.example.com. root.ad.example.com. (
                                  2         ; Serial
                             604800         ; Refresh
                              86400         ; Retry
                            2419200         ; Expire
                             604800 )       ; Negative Cache TTL
    ;
    @       IN      NS      ad.marvel.
    @       IN      A       127.0.0.1
    @       IN      AAAA    ::1
    ;
    ; AD horrible domains
    ;
    dc1.ad.example.com.    A       192.168.1.103
    _ldap._tcp.ad.example.com.     SRV     0 0 389  dc1.ad.example.com.
    _kerberos._tcp.ad.example.com.    SRV     0 0 88   dc1.ad.example.com.
    _ldap._tcp.dc._msdcs.ad.example.com.   SRV     0 0 389  dc1.ad.example.com.
    _kerberos._tcp.dc._msdcs.ad.example.com.    SRV     0 0 88   dc1.ad.example.com.
    gc._msdcs.ad.example.com.      SRV     0 0 3268 dc1.ad.example.com.
    

    Note:Is important to remember that the computer name of the server that has the AD role is dc1, if we used a diff name we have to change the configuration accordingly.

  3. Restart the bind9 service:

    sudo /etc/init.d/bind9 restart
    
  4. Install the AD server and specify that you DO NOT want to set that server as a DNS server too.
  5. Set the AD server to use your Ubuntu with your bind9 as the DNS server.

There are lots of things missing if you wanted to use this a set up for a corporate network, but it does the trick in my LAN since I do not have AD duplication or other fancy things. Maybe is useful for you home, who knows..

Read more
Roberta Nilerud

Putting bookmark sync to bed

It’s been a busy few months for the team at Ubuntu One with our official release of Windows at the end of September and then Ubuntu 11.10 last week. Those of you who have already upgraded to 11.10 may have noticed that Ubuntu One no longer supports bookmarks sync, this is because we have decided to discontinue bookmarks sync as a feature. There are a few reasons for this, the main one being that we felt we were not delivering a quality experience to our users. We have been aware for some time about performance issues with bookmark sync and users have feedback that in many cases it’s not been working properly. We would like to apologise to those of you who have been affected by this. We have tried repeatedly to find a good fix, but alas to no avail. This is mostly due to factors outside of our control and is burdened further by providers constantly changing their API’s, making it expensive and time consuming for us to maintain an old service that isn’t delivering much user value.

We want our data sync services to have the same high quality as our file sync and music streaming services, so in the longer term we are aiming for a major upgrade to our data sync infrastructure. Enabling us to provide a robust platform that will serve as the foundation for future services we and other developers will build. We’ll have more details in a future post.

 

Read more
Roberta Nilerud

Ubuntu One now works on Windows!

It’s been a long time coming but today we are thrilled to tell you that the much anticipated Ubuntu One official client for Windows is now available for download.

A question we get asked a lot is…..why an Ubuntu One Windows client?

Well there are a few reasons: The most important is we listen to our users. We have long received feedback from Ubuntu users regarding their evolving needs to manage all their content  from a single, secure place across multiple platforms and devices. We’ve looked at many use cases, the most common being the Ubuntu user who is using more than one device or OS. Many people have to work in Windows or Mac environments, even if they prefer to use Ubuntu as their home desktop or OS of choice. Another case is enabling more opportunities for sharing across platforms. For example families using different operating systems in one household can use Ubuntu One as their central place to store all their music, documents, photos and share them easily with each other and friends.

Ubuntu One has a clearly defined strategy of being multi-platform, Windows is one element of that strategy. We believe in giving all users regardless of platform, access to one of the best personal cloud services available. We want as many people as possible to be able to enjoy Ubuntu One and as a consequence, want to know more about all the great benefits of using Ubuntu.

Based on all of this feedback we released our first Windows client beta back in November 2010. Since then, it’s certainly been a labour of love for the team but they have done an excellent job creating a lightweight Windows desktop app so you can use all the great features of Ubuntu One on a Windows machine. This is a major milestone for the Ubuntu One team and we’d like to say well done to Roberto, Manuel, Natalia, Alejandro, Diego, Lisette, Andrews- Junior, Joshua, Sian and everyone else who has contributed.

However, the real heroes are our loyal beta testers, so we wanted to take this opportunity to say a great big thank you to our community who have been reporting bugs and giving us feedback for twelve months. Due to this we have been able to improve the Ubuntu One Windows installer to the slick official version now available for downloadWe couldn’t have done it without you!

Ubuntu One for Windows is easy to use, all you have to do is:

  1. Save the installer to your computer
    Save Ubuntu One for Windows installer
  2. Double-click on the download in your web browser’s download status to launch the installer.
    Run the Ubuntu One for Windows installer
  3. Setup – If you already have an Ubuntu One account sign in with your existing account. If you are new to Ubuntu One, you will be asked to set up an Ubuntu One Free account, this also gives you 5GB of free cloud storage. On successful registration an email will be sent to you with a verification code. Copy and paste that code into the installer when prompted.
    Setup Ubuntu One for Windows
  4. Next click the “Start setup” button to select folders you want to sync to your personal cloud. You can select folders on your computer to sync with your personal cloud at any time in the application.
    Select folders to sync with Ubuntu One for Windows
  5. Ubuntu One will take care of the rest…you are now ready to get started syncing, sharing and streaming!
    Ubuntu One for Windows running

If you want any more information about Ubuntu One for Windows or in general contact us on the Ubuntu Community Forums, facebook and twitter

The Ubuntu One team

Read more
Roberta Nilerud

Our first App Developer talk

Back in July we officially launched our App Developer Program. Last Thursday we held our first app developer evening at Manchester Metropolitan University, it was an informal event for students and local developers.

We had a great time so we’d like to say a big thanks to Darren Dancey from Manchester Met for inviting us and thanks to everyone else who came along.

Stuart Langridge was on top form as usual and held a brilliant talk, then went on to hold court in the pub afterwards. We received some really helpful feedback from the attendees, with the majority of people saying they found the talk both useful and interesting.

Some great questions where asked and we had lively discussions around some really interesting topics, always good to get out there and talk to developers to further understand their needs and motivations. It’s certainly something we’ll be looking to do again so keep your eye on the blog for future event details.

Read more
Roberta Nilerud

A handy update this week to our Music Streaming app for Android, tons of small bug fixes have been made that will improve overall performance and a demo mode has been added.

So, what’s this ‘demo mode’?…. I hear you ask. Well,  it’s a way to play around with our Music Streaming app without having to sign up to the Music Streaming subscription and upload your own music beforehand. The demo mode lets you stream from 98 free tracks instantly with no commitment, so you can sample Music Streaming for Android straight away. The app itself is free to download and demo, if you like all the great features such as offline listening and want to continue to use it you’ll have to add on a Music Streaming subscription. This plan is great value at just $3.99 per month, which now includes 20GB of storage built in so you can continue to grow your music collection. You still get a 30 day free trial and on top of that if you sign up for twelve months you only pay $39.99, so that’s an additional two months for free.

Happy listening!

Also, just a quick reminder about our App Developer evening on Thursday at Manchester Metropolitan University, where Stuart Langridge will be talking Ubuntu One apps from 7pm , it’s free and there’s still time to register. Hope to see you there.

Read more
Roberta Nilerud

A few weeks ago we told you that we’d submitted our shiny new Music Streaming iPhone app, well after some time doing the ‘app review dance’ with Apple we’re pleased to tell you it’s now live and ready for you to download

The new Ubuntu One Music Streaming app for iPhone comes packed full of great functionality and an elegant new UI, so you can wirelessly sync your entire music collection saved to your Ubuntu One personal cloud. Along with supporting MP3′s and non-DRM iTunes song formats we’ve made managing your music on the fly easy, so you can browse and search by artist, album, or song title. You can also build and listen to playlists and control your listening with skip, shuffle and repeat functions.

What makes it perfect for everyday use is that you can listen offline without a connection and enjoy your favorite songs at the gym, on that run, commute or flight. No need to worry if you get a call half way through your favourite chorus, as it will automatically resume playing when you’ve finished your call.

You can try the Ubuntu One Music Streaming on iPhone free for 30 days, after the free trial period expires Music Streaming is just $3.99 per month which now has 20GB of storage included in the price. Plus if you sign up for 12 months you get 2 months for free!

So what are you waiting for?!….Simply download from the App store and try it free for 30 days.

Happy listening!

Read more
Joshua Hoover

Stuart LangridgeLast week we told you that we launched our App Developer Program. Today we’re pleased to announce our first Ubuntu One App Developer event. Our App Developer Program is open to everybody and on Thursday 1st of September we’re inviting any interested developers to an evening of talking Ubuntu One apps and a drink or two with our futures architect, Stuart Langridge, at Manchester Metropolitan University in the UK from 7pm. If you’re interested in building apps for mobile, web or the desktop to work with or use Ubuntu One’s features, or you want to bring Ubuntu One to a new platform, or you just want to hear about what’s going on, come along!

It’s a chance to bounce around some ideas, ask questions and chat with like-minded folks so come and join us. Please let us know you’re coming at http://www.eventbrite.com/event/1981804631

We’re really looking forward to seeing you there on the 1st and hearing what imaginative Ubuntu One app ideas are out there…and helping you make them! To find out more about the Ubuntu One APIs we’ve already published, for file syncing and music streaming and data storage, take a look at  https://one.ubuntu.com/developer/.

Read more
Roberta Nilerud

Fresh off the back of our super successful Android Files app launch, we now get to share even more exciting news. First of all, back in May we surpassed the 1 million global user mark! This is a significant milestone for us at Ubuntu One as it means that over a million people all over the world are enjoying Ubuntu One services to sync files, share and collaborate with family, friends, colleagues and stream music.

We’re passionate about building great Ubuntu One services and seeing how people love using them, so we’d like to say a big thank you to all our loyal users for supporting Ubuntu One. As such,  we have made some changes to our plans. From today, Ubuntu One Basic will become Ubuntu One Free and users will get 5GB of free storage when they set up an account. Current  users of Ubuntu One Basic will see their free storage allowance automatically increase from 2GB to 5GB. We are also changing our current Mobile plan to Music Streaming for Android and iPhone: this plan will now include 20GB of storage built in for the same great price of $3.99 per month – and remember, this service works anywhere in the world. Existing mobile plan subscribers will be instantly upgraded to the new Music Streaming plan and automatically get the 20GB of storage. You can still buy additional storage as you need it, in the same 20GB increments and at the same price of $2.99 per month. You’ll find all the information about new plans on our shiny new website which comes with improved navigation and help section.

But we’re not done with the good news! The Ubuntu One App Developer Program is now public. We’re firm believers that we don’t have to build everything ourselves and we know there’s a mass of great ideas and amazing developer talent out there: that’s why our App Developer Program is open to everybody, on any platform so we can’t wait to see you get involved!

If you have any more questions about any of these changes please visit our help section on the website or get in touch on Ubuntu Community Forums, Facebook or Twitter.

Phew! You’d think with all those changes the team would be able to kick back and relax, but  the hard work isn’t over –  we’re still pushing to get a major upgrade to the Ubuntu One Windows Beta out soon so keep your eye on the blog!

Read more
Roberta Nilerud

Meet the new kid on the block

Hi there,

I just wanted to take the time to introduce everyone to the latest member of the Ubuntu One team, Duane Hinnen. We are really excited that Duane has officially joined the team as a Customer Support Specialist a role that Duane has been dedicating his spare time to for quite a while now, in fact many of you may already know Duane by his moniker duanedesign.

In his own word Duane says “I have been very passionate about the Ubuntu One project and the concept of personal cloud spaces for quite some time. I started getting interested in Ubuntu One in 2009 while I was developing an application called Stipple which used Ubuntu One. I get a real sense of satisfaction helping Ubuntu One users and it is a dream come true to have the opportunity to spend even more time ensuring Ubuntu One users have the best possible experience and to create a sense of personal, human to human connection.”

What this means is that Duane is here to listen to you answer any questions and help you resolve any problems you may have, he’ll be actively available to our users on the Ubuntu Community Forums, facebook and twitter so go say hi!

Read more
beuno

After a long and interesting journey, today we've released Ubuntu One Files for Android.

The app started being developed by Micha? Karnicki as a Google Summer of Code project, and he did such a fantastic job at it that we hired him on full time and teamed him up Chad Miller to end up releasing a fantastically polished app. It got immediately featured in the press!
It was built on top of our public APIs, documented here: https://one.ubuntu.com/developer/

Besides it letting you access all your files stored in Ubuntu One, it has a very cool feature to auto-sync all the pictures on your phone, having an instant backup of them, and a convenient place to share them!

I'm super proud of the work we put out.

Also, as with all the rest of our clients, it's open source and you can get it in Launchpad

Read more
Joshua Hoover

It’s been on it’s way for a while now, so we are pleased to announce that our new free Android files app is ready for download from the Android Market.Ubuntu One files app for Android QR code

So what does this super new files app do? Well, Ubuntu One’s files app for Android gives you the freedom to take your files, photos and more with you and access them on the fly. It’s been picked as Pocket-lint’s ‘App of the Day’ today so see the full review here.

You can secure and manage your photos, files and folders directly from your Android device anywhere in the world. You can browse, select and download all your files and folders as well as upload and send files directly from your phone.

Ubuntu One files app for Android browsing files

What’s really cool is that Ubuntu One files automatically backs up photographs taken from your Android phone’s camera directly to your Ubuntu One personal cloud. Giving you peace of mind knowing that all the great photos on your mobile are backed up and available for you to share. Speaking of sharing, you can do that directly from the app – just tap and hold on the file or photo you want to share and instantly post it straight to Facebook, Twitter, or your blog.

Ubuntu One files app for Android managing and sharing a file

Other news, last week we submitted our new Music streaming app for iPhone to the app store. We’ll tell you more as soon as it’s available for download so keep your eye on our blog.

Read more
mandel

At Ubuntu One we required to be able to use named pipes on windows for IPC. This is a ver normal process in multi-process applications like the one we are going to provide, but in our case we had a twist, we are using twisted. As some of you may know there is not default reactor that would allow you to write a protocol in twisted and allows to use named pipes as the transport of the protocol. Well this was until very recently.

Txnamedpipes (lp:txnamedpipes) is a project that provides a ICOP based reactor that allows to use namedpipes for the transport of your protocol. At the moment we are confident that the implementation would allow you to use spred.pb or a custom protocol on twisted 10 and later on Windows 7 (we have been able to find a number of issues on Windows XP). The following is a small example of a spread.pb service and client that uses a named pipe for communication.

from txnamedpipes.reactor import install
install()
from twisted.spread import pb
from twisted.internet import reactor
 
class Echoer(pb.Root):
    def remote_echo(self, st):
        print 'echoing:', st
        return st
 
if __name__ == '__main__':
    reactor.listenPipe('\\\\.\\pipe\\test_pipe',
                               pb.PBServerFactory(Echoer()))
    reactor.run()
from txnamedpipes.reactor import install
install()
from twisted.spread import pb
from twisted.internet import reactor
from twisted.python import util
 
factory = pb.PBClientFactory()
reactor.connectPipe('\\\\.\\pipe\\test_pipe', factory)
d = factory.getRootObject()
d.addCallback(lambda object: object.callRemote("echo", 
                      "hello network"))
d.addCallback(lambda echo: 'server echoed: '+echo)
d.addErrback(lambda reason: 'error: '+str(reason.value))
d.addCallback(util.println)
d.addCallback(lambda _: reactor.stop())
reactor.run()

The code has the MIT license and we hope that other people find it useful.

Read more
mandel

Pywin32 is a very cool project that allows you to access the win api without having to go through ctypes and deal with all the crazy parameters that COM is famous for. Unfortunately sometimes it has som issues which you face only a few times in your life.

This case I found a bug where GetFileSecurity does not use the GetFileSecurityW method but the w-less version. For those who don’t have to deal with this terrible details, the W usually means that the functions knows how to deal with utf-8 strings (backward compatibility can be a problem sometimes). I have reported the bug but for those that are in a hurry here is the patch:

diff -r 7dce71d174a9 win32/src/win32security.i
--- a/win32/src/win32security.i	Sat Jun 18 10:16:06 2011 -0400
+++ b/win32/src/win32security.i	Mon Jun 20 14:15:27 2011 +0200
@@ -2108,7 +2108,7 @@
  if (!PyWinObject_AsTCHAR(obFname, &fname))
   goto done;
 
-	if (GetFileSecurity(fname, info, psd, dwSize, &dwSize)) {
+	if (GetFileSecurityW(fname, info, psd, dwSize, &dwSize)) {
   PyErr_SetString(PyExc_RuntimeError, "Can't query for SECURITY_DESCRIPTOR size info?");
   goto done;
  }
@@ -2117,7 +2117,7 @@
   PyErr_SetString(PyExc_MemoryError, "allocating SECURITY_DESCRIPTOR");
   goto done;
  }
- if (!GetFileSecurity(fname, info, psd, dwSize, &dwSize)) {
+ if (!GetFileSecurityW(fname, info, psd, dwSize, &dwSize)) {
   PyWin_SetAPIError("GetFileSecurity");
   goto done;
  }
@@ -2153,7 +2153,7 @@
  PSECURITY_DESCRIPTOR psd;
  if (!PyWinObject_AsSECURITY_DESCRIPTOR(obsd, &psd))
   goto done;
-	if (!SetFileSecurity(fname, info, psd)) {
+	if (!SetFileSecurityW(fname, info, psd)) {
   PyWin_SetAPIError("SetFileSecurity");
   goto done;
  }

Read more
Joshua Hoover

As many of you will already know, today Ubuntu 11.04 introduced Unity, Ubuntu’s new interface, which is simpler, easier to use and more beautiful than previous editions of Ubuntu. We want to say a big well done to everyone who has contributed. For more on Ubuntu 11.04 see ubuntu.com.

Along with Unity there are some great improvements to Ubuntu One. Once upgraded to Ubuntu 11.04 you will see that Ubuntu One is more easily accessible in the launcher. We gave Ubuntu One preferences an all new look, new features, and even a new name, Ubuntu One control panel. The control panel allows selective syncing so you can easily manage the cloud folders you want synced locally and easily view which folders have been shared with you.

Ubuntu One control panel on first open Ubuntu One control panel web folders

Some other great news is that for some time now the team has been working hard to improve overall speed and performance. Many of you will notice this already and over the next few weeks, as we finish our server upgrades, everyone will be getting their files synced up to 200x faster. Yes, we’ve seen real world performance gains of up to 200x faster!

In addition to improvements in Ubuntu 11.04, we’ve also improved contacts on the web. For starters, there’s an all new look and feel that makes it faster and easier to manage your contacts. You can now delete and merge contacts in bulk. Not content with plain old merging, we also added smart merging. Click the new Find & merge duplicates button and it will find any duplicate contacts and allow you to merge them in one click.

Facebook contacts in Ubuntu One

The enhancements to contacts are great, but it would be even better if you could pull in your contacts from Facebook. Now you can. Seamless import from Facebook includes your friends’ profile pictures, first, middle and last name, birthday, ‘about me’ and any website they have listed. What’s really cool is it will merge existing contacts automatically for you.

Want to give importing your Facebook contacts a try? Follow the steps on our project wiki. Don’t worry, we don’t send messages to your contacts, post to your Facebook wall, or do anything other than import your Facebook contacts.

Ubuntu One Facebook import

Well that’s it for now folks but keep your eye on us for upcoming news about updates to our Windows beta, Android file sync app and more.

Read more