Synnefo

#

# Copyright (c) 2011 Greek Research and Technology Network

#

from api.models import Container, Object, Metadata

from django.contrib import admin

admin.site.register(Container)

admin.site.register(Object)

admin.site.register(Metadata)

#

# Copyright (c) 2011 Greek Research and Technology Network

#

def camelCase(s):

    return s[0].lower() + s[1:]

class Fault(Exception):

    def __init__(self, message='', details='', name=''):

        Exception.__init__(self, message, details, name)

        self.message = message

        self.details = details

        self.name = name or camelCase(self.__class__.__name__)

class NotModified(Fault):

    code = 304

class BadRequest(Fault):

    code = 400

class Unauthorized(Fault):

    code = 401

class ResizeNotAllowed(Fault):

    code = 403

class ItemNotFound(Fault):

    code = 404

class LengthRequired(Fault):

    code = 411

class PreconditionFailed(Fault):

    code = 412

class RangeNotSatisfiable(Fault):

    code = 416

class UnprocessableEntity(Fault):

    code = 422

class ServiceUnavailable(Fault):

    code = 503

#

# Copyright (c) 2011 Greek Research and Technology Network

#

from django.http import HttpResponse

from django.template.loader import render_to_string

from django.utils import simplejson as json

from django.utils.http import http_date, parse_etags

try:

    from django.utils.http import parse_http_date_safe

except:

    from pithos.api.util import parse_http_date_safe

from pithos.api.faults import Fault, NotModified, BadRequest, Unauthorized, LengthRequired, PreconditionFailed, RangeNotSatisfiable, UnprocessableEntity

from pithos.api.util import get_object_meta, get_range, api_method

from pithos.backends.dummy_debug import *

import logging

logging.basicConfig(level=logging.DEBUG)

@api_method('GET')

def authenticate(request):

    # Normal Response Codes: 204

    # Error Response Codes: serviceUnavailable (503),

    #                       unauthorized (401),

    #                       badRequest (400)

    x_auth_user = request.META.get('HTTP_X_AUTH_USER')

    x_auth_key = request.META.get('HTTP_X_AUTH_KEY')

    if not x_auth_user or not x_auth_key:

        raise BadRequest('Missing auth user or key.')

    response = HttpResponse(status = 204)

    response['X-Auth-Token'] = 'eaaafd18-0fed-4b3a-81b4-663c99ec1cbb'

    # TODO: Do we support redirections?

    #response['X-Storage-Url'] = 'https://storage.grnet.gr/pithos/v1.0/<some reference>'

    return response

def account_demux(request, v_account):

    if request.method == 'HEAD':

        return account_meta(request, v_account)

    elif request.method == 'GET':

        return container_list(request, v_account)

    else:

        return method_not_allowed(request)

def container_demux(request, v_account, v_container):

    if request.method == 'HEAD':

        return container_meta(request, v_account, v_container)

    elif request.method == 'GET':

        return object_list(request, v_account, v_container)

    elif request.method == 'PUT':

        return container_create(request, v_account, v_container)

    elif request.method == 'DELETE':

        return container_delete(request, v_account, v_container)

    else:

        return method_not_allowed(request)

def object_demux(request, v_account, v_container, v_object):

    if request.method == 'HEAD':

        return object_meta(request, v_account, v_container, v_object)

    elif request.method == 'GET':

        return object_read(request, v_account, v_container, v_object)

    elif request.method == 'PUT':

        return object_write(request, v_account, v_container, v_object)

    elif request.method == 'COPY':

        return object_copy(request, v_account, v_container, v_object)

    elif request.method == 'POST':

        return object_update(request, v_account, v_container, v_object)

    elif request.method == 'DELETE':

        return object_delete(request, v_account, v_container, v_object)

    else:

        return method_not_allowed(request)

@api_method('HEAD')

def account_meta(request, v_account):

    # Normal Response Codes: 204

    # Error Response Codes: serviceUnavailable (503),

    #                       itemNotFound (404),

    #                       unauthorized (401),

    #                       badRequest (400)

    container_count, bytes_count = get_account_meta(request.user)

    response = HttpResponse(status = 204)

    response['X-Account-Container-Count'] = container_count

    response['X-Account-Total-Bytes-Used'] = bytes_count

    return response

@api_method('GET', format_allowed = True)

def container_list(request, v_account):

    # Normal Response Codes: 200, 204

    # Error Response Codes: serviceUnavailable (503),

    #                       unauthorized (401),

    #                       badRequest (400)

    marker = request.GET.get('marker')

    limit = request.GET.get('limit')

    if limit:

        try:

            limit = int(limit)

        except ValueError:

            limit = None

    containers = list_containers(request.user, marker, limit)

    if len(containers) == 0:

        return HttpResponse(status = 204)

    if request.serialization == 'xml':

        data = render_to_string('containers.xml', {'account': request.user, 'containers': containers})

    elif request.serialization  == 'json':

        data = json.dumps(containers)

    else:

        data = '\n'.join(x['name'] for x in containers)

    return HttpResponse(data, status = 200)

@api_method('HEAD')

def container_meta(request, v_account, v_container):

    # Normal Response Codes: 204

    # Error Response Codes: serviceUnavailable (503),

    #                       itemNotFound (404),

    #                       unauthorized (401),

    #                       badRequest (400)

    object_count, bytes_count = get_container_meta(request.user, v_container)

    response = HttpResponse(status = 204)

    response['X-Container-Object-Count'] = object_count

    response['X-Container-Bytes-Used'] = bytes_count

    return response

@api_method('PUT')

def container_create(request, v_account, v_container):

    # Normal Response Codes: 201, 202

    # Error Response Codes: serviceUnavailable (503),

    #                       itemNotFound (404),

    #                       unauthorized (401),

    #                       badRequest (400)

    if create_container(request.user, v_container):

        return HttpResponse(status = 201)

    else:

        return HttpResponse(status = 202)

@api_method('DELETE')

def container_delete(request, v_account, v_container):

    # Normal Response Codes: 204

    # Error Response Codes: serviceUnavailable (503),

    #                       itemNotFound (404),

    #                       unauthorized (401),

    #                       badRequest (400)

    object_count, bytes_count = get_container_meta(request.user, v_container)

    if object_count > 0:

        return HttpResponse(status = 409)

    delete_container(request.user, v_container)

    return HttpResponse(status = 204)

@api_method('GET', format_allowed = True)

def object_list(request, v_account, v_container):

    # Normal Response Codes: 200, 204

    # Error Response Codes: serviceUnavailable (503),

    #                       itemNotFound (404),

    #                       unauthorized (401),

    #                       badRequest (400)

    path = request.GET.get('path')

    prefix = request.GET.get('prefix')

    delimiter = request.GET.get('delimiter')

    logging.debug("path: %s", path)

    # Path overrides prefix and delimiter.

    if path:

        prefix = path

        delimiter = '/'

    # Naming policy.

    if prefix and delimiter:

        prefix = prefix + delimiter

    marker = request.GET.get('marker')

    limit = request.GET.get('limit')

    if limit:

        try:

            limit = int(limit)

        except ValueError:

            limit = None

    objects = list_objects(request.user, v_container, prefix, delimiter, marker, limit)

    if len(objects) == 0:

        return HttpResponse(status = 204)

    if request.serialization == 'xml':

        data = render_to_string('objects.xml', {'container': v_container, 'objects': objects})

    elif request.serialization  == 'json':

        data = json.dumps(objects)

    else:

        data = '\n'.join(x['name'] for x in objects)

    return HttpResponse(data, status = 200)

@api_method('HEAD')

def object_meta(request, v_account, v_container, v_object):

    # Normal Response Codes: 204

    # Error Response Codes: serviceUnavailable (503),

    #                       itemNotFound (404),

    #                       unauthorized (401),

    #                       badRequest (400)

    info = get_object_meta(request.user, v_container, v_object)

    response = HttpResponse(status = 204)

    response['ETag'] = info['hash']

    response['Content-Length'] = info['bytes']

    response['Content-Type'] = info['content_type']

    response['Last-Modified'] = http_date(info['last_modified'])

    for k, v in info['meta'].iteritems():

        response['X-Object-Meta-%s' % k.capitalize()] = v

    return response

@api_method('GET')

def object_read(request, v_account, v_container, v_object):

    # Normal Response Codes: 200, 206

    # Error Response Codes: serviceUnavailable (503),

    #                       rangeNotSatisfiable (416),

    #                       preconditionFailed (412),

    #                       itemNotFound (404),

    #                       unauthorized (401),

    #                       badRequest (400),

    #                       notModified (304)

    info = get_object_meta(request.user, v_container, v_object)

    response = HttpResponse()

    response['ETag'] = info['hash']

    response['Content-Type'] = info['content_type']

    response['Last-Modified'] = http_date(info['last_modified'])

    # Range handling.

    range = get_range(request)

    if range is not None:

        offset, length = range

        if not length:

            length = 0

        if offset + length > info['bytes']:

            raise RangeNotSatisfiable()

        response['Content-Length'] = length        

        response.status_code = 206

    else:

        offset = 0

        length = 0

        response['Content-Length'] = info['bytes']

        response.status_code = 200

    # Conditions (according to RFC2616 must be evaluated at the end).

    if_match = request.META.get('HTTP_IF_MATCH')

    if if_match is not None and if_match != '*':

        if info['hash'] not in parse_etags(if_match):

            raise PreconditionFailed()

    if_none_match = request.META.get('HTTP_IF_NONE_MATCH')

#     if if_none_match is not None:

#         if if_none_match = '*' or info['hash'] in parse_etags(if_none_match):

#             raise NotModified()

    if_modified_since = request.META.get('HTTP_IF_MODIFIED_SINCE')

    if if_modified_since is not None:

        if_modified_since = parse_http_date_safe(if_modified_since)

    if if_modified_since is not None and info['last_modified'] <= if_modified_since:

        raise NotModified()

    if_unmodified_since = request.META.get('HTTP_IF_UNMODIFIED_SINCE')

    if if_unmodified_since is not None:

        if_unmodified_since = parse_http_date_safe(if_unmodified_since)

    if if_unmodified_since is not None and info['last_modified'] > if_unmodified_since:

        raise PreconditionFailed()

    response.content = get_object_data(request.user, v_container, v_object, offset, length)

    return response

@api_method('PUT')

def object_write(request, v_account, v_container, v_object):

    # Normal Response Codes: 201

    # Error Response Codes: serviceUnavailable (503),

    #                       unprocessableEntity (422),

    #                       lengthRequired (411),

    #                       itemNotFound (404),

    #                       unauthorized (401),

    #                       badRequest (400)

    copy_from = request.META.get('HTTP_X_COPY_FROM')

    if copy_from:

        parts = copy_from.split('/')

        if len(parts) < 3 or parts[0] != '':

            raise BadRequest('Bad X-Copy-From path.')

        copy_container = parts[1]

        copy_name = '/'.join(parts[2:])

        info = get_object_meta(request.user, copy_container, copy_name)

        content_length = request.META.get('CONTENT_LENGTH')

        content_type = request.META.get('CONTENT_TYPE')

        if not content_length:

            raise LengthRequired()

        if content_type:

            info['content_type'] = content_type

        meta = get_object_meta(request)

        for k, v in meta.iteritems():

            info['meta'][k] = v

        copy_object(request.user, copy_container, copy_name, v_container, v_object)

        update_object_meta(request.user, v_container, v_object, info)

        response = HttpResponse(status = 201)

    else:

        content_length = request.META.get('CONTENT_LENGTH')

        content_type = request.META.get('CONTENT_TYPE')

        if not content_length or not content_type:

            raise LengthRequired()

        meta = get_object_meta(request)

        info = {'bytes': content_length, 'content_type': content_type, 'meta': meta}

        etag = request.META.get('HTTP_ETAG')

        if etag:

            etag = parse_etags(etag)[0] # TODO: Unescape properly.

            info['hash'] = etag

        data = request.read()

        # TODO: Hash function.

        # etag = hash(data)

        # if info.get('hash') and info['hash'] != etag:

        #     raise UnprocessableEntity()

        update_object_data(request.user, v_container, v_name, info, data)

        response = HttpResponse(status = 201)

        # response['ETag'] = etag

    return response

@api_method('COPY')

def object_copy(request, v_account, v_container, v_object):

    # Normal Response Codes: 201

    # Error Response Codes: serviceUnavailable (503),

    #                       itemNotFound (404),

    #                       unauthorized (401),

    #                       badRequest (400)

    destination = request.META.get('HTTP_DESTINATION')

    if not destination:

        raise BadRequest('Missing Destination.');

    parts = destination.split('/')

    if len(parts) < 3 or parts[0] != '':

        raise BadRequest('Bad Destination path.')

    dest_container = parts[1]

    dest_name = '/'.join(parts[2:])

    info = get_object_meta(request.user, v_container, v_object)

    content_type = request.META.get('CONTENT_TYPE')

    if content_type:

        info['content_type'] = content_type

    meta = get_object_meta(request)

    for k, v in meta.iteritems():

        info['meta'][k] = v

    copy_object(request.user, v_container, v_object, dest_container, dest_name)

    update_object_meta(request.user, dest_container, dest_name, info)

    response = HttpResponse(status = 201)

@api_method('POST')

def object_update(request, v_account, v_container, v_object):

    # Normal Response Codes: 202

    # Error Response Codes: serviceUnavailable (503),

    #                       itemNotFound (404),

    #                       unauthorized (401),

    #                       badRequest (400)

    meta = get_object_meta(request)

    update_object_meta(request.user, v_container, v_object, meta)

    return HttpResponse(status = 202)

@api_method('DELETE')

def object_delete(request, v_account, v_container, v_object):

    # Normal Response Codes: 204

    # Error Response Codes: serviceUnavailable (503),

    #                       itemNotFound (404),

    #                       unauthorized (401),

    #                       badRequest (400)

    delete_object(request.user, v_container, v_object)

    return HttpResponse(status = 204)

@api_method()

def method_not_allowed(request):

    raise BadRequest('Method not allowed.')

#

# Copyright (c) 2011 Greek Research and Technology Network

#

from django.db import models

class Container(models.Model):

    account = models.CharField(max_length = 256)

    name = models.CharField(max_length = 256)

    date_created = models.DateTimeField(auto_now_add = True)

    def __unicode__(self):

        return self.name

class Object(models.Model):

    container = models.ForeignKey(Container)

    name = models.CharField(max_length = 1024)

    length = models.IntegerField()

    type = models.CharField(max_length = 256)

    hash = models.CharField(max_length = 256)

    data = models.FileField(upload_to = 'data', max_length = 256)

    date_created = models.DateTimeField(auto_now_add = True)

    date_modified = models.DateTimeField(auto_now = True)

    def __unicode__(self):

        return self.name

class Metadata(models.Model):

    object = models.ForeignKey(Object)

    name = models.CharField(max_length = 256)

    value = models.CharField(max_length = 1024)

    date_created = models.DateTimeField(auto_now_add = True)

    date_modified = models.DateTimeField(auto_now = True)

{% spaceless %}

<?xml version="1.0" encoding="UTF-8"?>

<account name="{{ account }}">

  {% for container in containers %}

  <container>

    <name>{{ container.name }}</name>

    <count>{{ container.count }}</count>

    <bytes>{{ container.bytes }}</bytes>

  </container>

  {% endfor %}

</account>

{% endspaceless %}

{% spaceless %}

<?xml version="1.0" encoding="UTF-8"?>

<container name="{{ container }}">

  {% for object in objects %}

  <object>

    <name>{{ object.name }}</name>

    <hash>{{ object.hash }}</hash>

    <bytes>{{ object.bytes }}</bytes>

    <content_type>{{ object.content_type }}</content_type>

    <last_modified>{{ object.last_modified }}</last_modified>

  </object>

  {% endfor %}

</container>

{% endspaceless %}

"""

This file demonstrates two different styles of tests (one doctest and one

unittest). These will both pass when you run "manage.py test".

Replace these with more appropriate tests for your application.

"""

from django.test import TestCase

class SimpleTest(TestCase):

    def test_basic_addition(self):

        """

        Tests that 1 + 1 always equals 2.

        """

        self.failUnlessEqual(1 + 1, 2)

__test__ = {"doctest": """

Another way to test that 1 + 1 is equal to 2.

>>> 1 + 1 == 2

True

"""}

#

# Copyright (c) 2011 Greek Research and Technology Network

#

from django.conf.urls.defaults import *

# TODO: This only works when in this order.

# TODO: Define which characters can be used in each "path" component.

urlpatterns = patterns('pithos.api.functions',

    (r'^$', 'authenticate'),

    (r'^(?P<v_account>.+?)/(?P<v_container>.+?)/(?P<v_object>.+?)$', 'object_demux'),

    (r'^(?P<v_account>.+?)/(?P<v_container>.+?)$', 'container_demux'),

    (r'^(?P<v_account>.+?)$', 'account_demux')

)

#

# Copyright (c) 2011 Greek Research and Technology Network

#

from datetime import timedelta, tzinfo

from functools import wraps

from random import choice

from string import ascii_letters, digits

from time import time

from traceback import format_exc

from wsgiref.handlers import format_date_time

from django.conf import settings

from django.http import HttpResponse

from django.template.loader import render_to_string

from django.utils import simplejson as json

from pithos.api.faults import Fault, BadRequest, ItemNotFound, ServiceUnavailable

#from synnefo.db.models import SynnefoUser, Image, ImageMetadata, VirtualMachine, VirtualMachineMetadata

import datetime

import dateutil.parser

import logging

import re

import calendar

# Part of newer Django versions.

__D = r'(?P<day>\d{2})'

__D2 = r'(?P<day>[ \d]\d)'

__M = r'(?P<mon>\w{3})'

__Y = r'(?P<year>\d{4})'

__Y2 = r'(?P<year>\d{2})'

__T = r'(?P<hour>\d{2}):(?P<min>\d{2}):(?P<sec>\d{2})'

RFC1123_DATE = re.compile(r'^\w{3}, %s %s %s %s GMT$' % (__D, __M, __Y, __T))

RFC850_DATE = re.compile(r'^\w{6,9}, %s-%s-%s %s GMT$' % (__D, __M, __Y2, __T))

ASCTIME_DATE = re.compile(r'^\w{3} %s %s %s %s$' % (__M, __D2, __T, __Y))

def parse_http_date(date):

    """

    Parses a date format as specified by HTTP RFC2616 section 3.3.1.

    The three formats allowed by the RFC are accepted, even if only the first

    one is still in widespread use.

    Returns an floating point number expressed in seconds since the epoch, in

    UTC.

    """

    # emails.Util.parsedate does the job for RFC1123 dates; unfortunately

    # RFC2616 makes it mandatory to support RFC850 dates too. So we roll

    # our own RFC-compliant parsing.

    for regex in RFC1123_DATE, RFC850_DATE, ASCTIME_DATE:

        m = regex.match(date)

        if m is not None:

            break

    else:

        raise ValueError("%r is not in a valid HTTP date format" % date)

    try:

        year = int(m.group('year'))

        if year < 100:

            if year < 70:

                year += 2000

            else:

                year += 1900

        month = MONTHS.index(m.group('mon').lower()) + 1

        day = int(m.group('day'))

        hour = int(m.group('hour'))

        min = int(m.group('min'))

        sec = int(m.group('sec'))

        result = datetime.datetime(year, month, day, hour, min, sec)

        return calendar.timegm(result.utctimetuple())

    except Exception:

        raise ValueError("%r is not a valid date" % date)

def parse_http_date_safe(date):

    """

    Same as parse_http_date, but returns None if the input is invalid.

    """

    try:

        return parse_http_date(date)

    except Exception:

        pass

def get_object_meta(request):

    """

    Get all X-Object-Meta-* headers in a dict.

    """

    prefix = 'HTTP_X_OBJECT_META_'

    return dict([(k[len(prefix):].lower(), v) for k, v in request.META.iteritems() if k.startswith(prefix)])

def get_range(request):

    """

    Parse a Range header from the request.

    Either returns None, or an (offset, length) tuple.

    If no offset is defined offset equals 0.

    If no length is defined length is None.

    """

    range = request.GET.get('range')

    if not range:

        return None

    range = range.replace(' ', '')

    if not range.startswith('bytes='):

        return None

    parts = range.split('-')

    if len(parts) != 2:

        return None

    offset, length = parts

    if offset == '' and length == '':

        return None

    if offset != '':

        try:

            offset = int(offset)

        except ValueError:

            return None

    else:

        offset = 0

    if length != '':

        try:

            length = int(length)

        except ValueError:

            return None

    else:

        length = None

    return (offset, length)

# def get_vm(server_id):

#     """Return a VirtualMachine instance or raise ItemNotFound."""

#     

#     try:

#         server_id = int(server_id)

#         return VirtualMachine.objects.get(id=server_id)

#     except ValueError:

#         raise BadRequest('Invalid server ID.')

#     except VirtualMachine.DoesNotExist:

#         raise ItemNotFound('Server not found.')

# 

# def get_vm_meta(server_id, key):

#     """Return a VirtualMachineMetadata instance or raise ItemNotFound."""

#     

#     try:

#         server_id = int(server_id)

#         return VirtualMachineMetadata.objects.get(meta_key=key, vm=server_id)

#     except VirtualMachineMetadata.DoesNotExist:

#         raise ItemNotFound('Metadata key not found.')

# 

# def get_image(image_id):

#     """Return an Image instance or raise ItemNotFound."""

#     

#     try:

#         image_id = int(image_id)

#         return Image.objects.get(id=image_id)

#     except Image.DoesNotExist:

#         raise ItemNotFound('Image not found.')

# 

# def get_image_meta(image_id, key):

#     """Return a ImageMetadata instance or raise ItemNotFound."""

# 

#     try:

#         image_id = int(image_id)

#         return ImageMetadata.objects.get(meta_key=key, image=image_id)

#     except ImageMetadata.DoesNotExist:

#         raise ItemNotFound('Metadata key not found.')

# 

# 

# def get_request_dict(request):

#     """Returns data sent by the client as a python dict."""

#     

#     data = request.raw_post_data

#     if request.META.get('CONTENT_TYPE').startswith('application/json'):

#         try:

#             return json.loads(data)

#         except ValueError:

#             raise BadRequest('Invalid JSON data.')

#     else:

#         raise BadRequest('Unsupported Content-Type.')

def update_response_headers(request, response):

    if request.serialization == 'xml':

        response['Content-Type'] = 'application/xml; charset=UTF-8'

    elif request.serialization == 'json':

        response['Content-Type'] = 'application/json; charset=UTF-8'

    else:

        response['Content-Type'] = 'text/plain; charset=UTF-8'

    if settings.TEST:

        response['Date'] = format_date_time(time())

def render_fault(request, fault):

    if settings.DEBUG or settings.TEST:

        fault.details = format_exc(fault)

#     if request.serialization == 'xml':

#         data = render_to_string('fault.xml', {'fault': fault})

#     else:

#         d = {fault.name: {'code': fault.code, 'message': fault.message, 'details': fault.details}}

#         data = json.dumps(d)

#     resp = HttpResponse(data, status=fault.code)

    resp = HttpResponse(status = fault.code)

    update_response_headers(request, resp)

    return resp

def request_serialization(request, format_allowed=False):

    """

    Return the serialization format requested.

    Valid formats are 'text' and 'json', 'xml' if `format_allowed` is True.

    """

    if not format_allowed:

        return 'text'

    format = request.GET.get('format')

    if format == 'json':

        return 'json'

    elif format == 'xml':

        return 'xml'

    # TODO: Do we care of Accept headers?

#     for item in request.META.get('HTTP_ACCEPT', '').split(','):

#         accept, sep, rest = item.strip().partition(';')

#         if accept == 'application/json':

#             return 'json'

#         elif accept == 'application/xml':

#             return 'xml'

    return 'text'

def api_method(http_method = None, format_allowed = False):

    """

    Decorator function for views that implement an API method.

    """

    def decorator(func):

        @wraps(func)

        def wrapper(request, *args, **kwargs):

            try:

                request.serialization = request_serialization(request, format_allowed)

                # TODO: Authenticate.

                # TODO: Return 401/404 when the account is not found.

                request.user = "test"

                # TODO: Check parameter sizes.

                if http_method and request.method != http_method:

                    raise BadRequest('Method not allowed.')

                resp = func(request, *args, **kwargs)

                update_response_headers(request, resp)

                return resp

            except Fault, fault:

                return render_fault(request, fault)

            except BaseException, e:

                logging.exception('Unexpected error: %s' % e)

                fault = ServiceUnavailable('Unexpected error')

                return render_fault(request, fault)

        return wrapper

    return decorator

# Create your views here.

import os

import sqlite3

import json

basepath = '/Users/butters/src/pithos/backends/content' #full path

if not os.path.exists(basepath):

    os.makedirs(basepath)

db = '/'.join([basepath, 'db'])

con = sqlite3.connect(db)

# Create tables

print 'Creating tables....'

sql = '''create table if not exists objects(name varchar(2560))'''

print sql

con.execute(sql)

# Save (commit) the changes

con.commit()

def create_container(name):

    """ creates a new container with the given name

    if it doesn't exists under the basepath """

    fullname = '/'.join([basepath, name])    

    if not os.path.exists(fullname):

        os.chdir(basepath)

        os.mkdir(name)

    else:

        raise NameError('Container already exists')

    return

def delete_container(name):

    """ deletes the container with the given name

        if it exists under the basepath """

    fullname = '/'.join([basepath, name])    

    if not os.path.exists(fullname):

        raise NameError('Container does not exist')

    if not list_objects(name):

        raise Error('Container is not empty')

    else:

        os.chdir(basepath)

        os.rmdir(name)

    return

def get_container_meta(name):

    """ returns a dictionary with the container metadata """

    fullname = '/'.join([basepath, name])

    if not os.path.exists(fullname):

        raise NameError('Container does not exist')

    contents = os.listdir(fullname) 

    count = len(contents)

    size = sum(os.path.getsize('/'.join([basepath, name, objectname])) for objectname in contents)

    return {'name': name, 'count': count, 'bytes': size}

def list_containers():

    return os.listdir(basepath) 

def list_objects(container, prefix='', delimiter=None):

    dir = '/'.join([basepath, container])

    if not os.path.exists(dir):

        raise NameError('Container does not exist')

    search_str = ''

    if prefix:

        search_str = '/'.join([search_str, prefix])

    #if delimiter:

    if None:

        search_str = ''.join(['%', search_str, '%', delimiter])

        print search_str

        c = con.execute('select * from objects where name like ''?'' order by name', (search_str,))

    else:

        search_str = ''.join(['%', search_str, '%'])

        print search_str

        c = con.execute('select * from objects where name like ''?'' order by name', (search_str,))

    l = []

    for row in c.fetchall():

        s = ''

        print row[0]

        rest = str(row[0]).split(prefix)[1]

        print rest

        #if delimiter:

        #    rest = rest.partition(delimiter)[0]

        #print rest

        folders = rest.split('/')[:-1]

        for folder in folders:

            path = ''.join([s, folder, '/'])

            if path not in l:

                l.append(path)

            s = ''.join([s, folder, '/'])

        l.append(rest)

    return l

def get_object_meta(container, name):

    dir = '/'.join([basepath, container])

    if not os.path.exists(dir):

        raise NameError('Container does not exist')

    else:

        os.chdir(dir)

    location = __get_object_linkinfo('/'.join([container, name]))

    location = '.'.join([location, 'meta'])

    f = open(location, 'r')

    data = json.load(f)

    f.close()

    return data

def get_object_data(container, name, offset=0, length=-1):

    dir = '/'.join([basepath, container])

    if not os.path.exists(dir):

        raise NameError('Container does not exist')

    else:

        os.chdir(dir)

    location = __get_object_linkinfo('/'.join([container, name]))

    f = open(location, 'r')

    if offset:

        f.seek(offset)

    data = f.read(length)

    f.close()

    return data

def update_object(container, name, data):

    dir = '/'.join([basepath, container])

    if not os.path.exists(dir):

        raise NameError('Container does not exist')

    try:

        location = __get_object_linkinfo('/'.join([container, name]))

    except NameError:

        # new object

        location = str(__save_linkinfo('/'.join([container, name])))

        print ':'.join(['Creating new location', location])

    __store_data(location, container, data)

    return

def update_object_meta(container, name, meta):

    dir = '/'.join([basepath, container])

    if not os.path.exists(dir):

        raise NameError('Container does not exist')

    try:

        location = __get_object_linkinfo('/'.join([container, name]))

    except NameError:

        # new object

        location = str(__save_linkinfo('/'.join([container, name])))

        print ':'.join(['Creating new location', location])

    __store_metadata(location, container, meta)

    return

def copy_object(src_container, src_name, dest_container, dest_name, meta):

    fullname = '/'.join([basepath, dest_container])    

    if not os.path.exists(fullname):

        raise NameError('Destination container does not exist')

    update_object(dest_container, dest_name, get_object_data(src_container, src_name))

    src_object_meta = get_object_meta(src_container, src_name)

    if (type(src_object_meta) == types.DictType):

        distinct_keys = [k for k in src_object_meta.keys() if k not in meta.keys()]

        for k in distinct_keys:

            meta[k] = src_object_meta[k]

            update_object_meta(dest_container, dest_name, meta)

    else:

        update_object_meta(dest_container, dest_name, meta)

    return

def delete_object(container, name):

    return

def __store_metadata(location, container, meta):

    dir = '/'.join([basepath, container])

    if not os.path.exists(dir):

        raise NameError('Container does not exist')

    else:

        os.chdir(dir)

    location = '.'.join([location, 'meta'])

    f = open(location, 'w')

    data = json.dumps(meta)

    f.write(data)

    f.close()

def __store_data(location, container, data):

    dir = '/'.join([basepath, container])

    if not os.path.exists(dir):

        raise NameError('Container does not exist')

    else:

        os.chdir(dir)

    f = open(location, 'w')

    f.write(data)

    f.close()

def __get_object_linkinfo(name):

    c = con.execute('select rowid from objects where name=''?''', (name,))

    row = c.fetchone()

    if row:

        return str(row[0])

    else:

        raise NameError('Object not found')

def __save_linkinfo(name):

    id = con.execute('insert into objects(name) values(?)', (name,)).lastrowid

    con.commit()

    return id

if __name__ == '__main__':

    dirname = 'papagian'

    #create_container(dirname)

    #assert os.path.exists(dirname)

    #assert os.path.isdir(dirname)

    #print get_container_meta(dirname)

    #update_object_meta(dirname, 'photos/animals/dog.jpg', {'name':'dog.jpg'})

    #update_object_meta(dirname, 'photos/animals/dog.jpg', {'name':'dog.jpg', 'type':'image', 'size':400})

    #print get_object_meta(dirname, 'photos/animals/dog.jpg')

    #f = open('dummy.py')

    #data  = f.read()

    #update_object(dirname, 'photos/animals/dog.jpg', data)

    #update_object(dirname, 'photos/animals/cat.jpg', data)

    #update_object(dirname, 'photos/animals/thumbs/cat.jpg', data)

    #update_object(dirname, 'photos/fruits/banana.jpg', data)

    #print list_objects(dirname, 'photos/animals');

    copy_object(dirname, 'photos/animals/dog.jpg', 'photos/animals/dog2.jpg')

    copy_object(dirname, 'photos/animals/dg.jpg', 'photos/animals/dog2.jpg')

"""

Dummy backend with debugging output

A backend with no functionality other than producing debugging output.

"""

import logging

def binary_search_name(a, x, lo = 0, hi = None):

    """

    Search a sorted array of dicts for the value of the key 'name'.

    Raises ValueError if the value is not found.

    a -- the array

    x -- the value to search for

    """

    if hi is None:

        hi = len(a)

    while lo < hi:

        mid = (lo + hi) // 2

        midval = a[mid]['name']

        if midval < x:

            lo = mid + 1

        elif midval > x: 

            hi = mid

        else:

            return mid

    raise ValueError()

def get_account_meta(account):

    logging.debug("get_account_meta: %s %s", account, name)

    return {'count': 13, 'bytes': 3148237468}

def create_container(account, name):

    """

    Returns True if the container was created, False if it already exists.

    """

    logging.debug("create_container: %s %s", account, name)

    return True

def delete_container(account, name):

    logging.debug("delete_container: %s %s", account, name)

    return

def get_container_meta(account, name):

    logging.debug("get_container_meta: %s %s", account, name)

    return {'count': 22, 'bytes': 245}

def list_containers(account, marker = None, limit = 10000):

    logging.debug("list_containers: %s %s %s", account, marker, limit)

    containers = [

            {'name': '1', 'count': 2, 'bytes': 123},

            {'name': '2', 'count': 22, 'bytes': 245},

            {'name': '3', 'count': 222, 'bytes': 83745},

            {'name': 'four', 'count': 2222, 'bytes': 274365}

        ]

    start = 0

    if marker:

        try:

            start = binary_search_name(containers, marker) + 1

        except ValueError:

            pass

    if not limit or limit > 10000:

        limit = 10000

    return containers[start:start + limit]

def list_objects(account, container, prefix = None, delimiter = None, marker = None, limit = 10000):

    logging.debug("list_objects: %s %s %s %s %s %s", account, container, prefix, delimiter, marker, limit)

    objects = [

            {'name': 'other', 'hash': 'dfgs', 'bytes': 0, 'content_type': 'application/directory', 'last_modified': 23453454},

            {'name': 'other/something', 'hash': 'vkajf', 'bytes': 234, 'content_type': 'application/octet-stream', 'last_modified': 878434562},

            {'name': 'photos', 'hash': 'kajdsn', 'bytes': 0, 'content_type': 'application/directory', 'last_modified': 1983274},

            {'name': 'photos/asdf', 'hash': 'jadsfkj', 'bytes': 0, 'content_type': 'application/directory', 'last_modified': 378465873},

            {'name': 'photos/asdf/test', 'hash': 'sudfhius', 'bytes': 37284, 'content_type': 'text/plain', 'last_modified': 93674212},

            {'name': 'photos/me.jpg', 'hash': 'sdgsdfgsf', 'bytes': 534, 'content_type': 'image/jpeg', 'last_modified': 262345345},

            {'name': 'photos/text.txt', 'hash': 'asdfasd', 'bytes': 34243, 'content_type': 'text/plain', 'last_modified': 45345345}

        ]

    if prefix or delimiter:

        if prefix:

            objects = [x for x in objects if x['name'].startswith(prefix)]

        if delimiter:

            pseudo_objects = {}

            for x in objects:

                pseudo_name = x['name'][len(prefix):]

                i = pseudo_name.find(delimiter)

                if i != -1:

                    pseudo_name = pseudo_name[:i]

                # TODO: Virtual directories.

                if pseudo_name not in pseudo_objects:

                    pseudo_objects[pseudo_name] = x

            objects = sorted(pseudo_objects.values(), key=lambda o: o['name'])

    start = 0

    if marker:

        try:

            start = binary_search_name(objects, marker) + 1

        except ValueError:

            pass

    if not limit or limit > 10000:

        limit = 10000

    return objects[start:start + limit]

def get_object_meta(account, container, name):

    logging.debug("get_object_meta: %s %s %s", account, container, name)

    meta = {'meat': 'bacon', 'fruit': 'apple'}

    return {'hash': 'asdfasd', 'bytes': 34243, 'content_type': 'text/plain', 'last_modified': 45345345, 'meta': meta}

def update_object_meta(account, container, name, meta):

    logging.debug("update_object_meta: %s %s %s %s", account, container, name, meta)

    for k, v in meta.iteritems():

        pass

    return

def get_object_data(account, container, name, offset=0, length=0):

    logging.debug("get_object_data: %s %s %s %s %s", account, container, name, offset, length)

    return ''

def update_object_data(account, container, name, meta, data):

    logging.debug("update_object_data: %s %s %s %s %s", account, container, name, meta, data)

    return

def copy_object(account, container, name, new_container, new_name):

    logging.debug("copy_object: %s %s %s %s %s", account, container, name, new_container, new_name)

    return

def delete_object(account, container, name):

    logging.debug("delete_object: %s %s %s", account, container, name)

    return

#!/usr/bin/env python

from django.core.management import execute_manager

try:

    import settings # Assumed to be in the same directory.

except ImportError:

    import sys

    sys.stderr.write("Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n(If the file settings.py does indeed exist, it's causing an ImportError somehow.)\n" % __file__)

    sys.exit(1)

if __name__ == "__main__":

    execute_manager(settings)