aboutsummaryrefslogtreecommitdiffstats
path: root/src/py/imc/blobhandle.py
blob: 40ff5236de88a69e63586a5eda143d9163be5863 (plain) (blame)
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
#! /usr/bin/env python

from abc import abstractmethod

class BlobHandle:
    READ = 0x1
    WRITE = 0x2
    CREATE = 0x4
    DELETE = 0x8
    WRITEMETA = 0x10
    def __init__(self, name, info, flag, blobclient):
        self._name = name
        self._info = info
        self._flag = flag
        self._blobclient = blobclient
        self._location = self._blobclient._location
        self._is_closed = False
        self._deltag = False
        self._written = False
        self._createtag = False
        self._need_commit = False
        self._tmpfile = None
        self._blobpath = ''.join([self._location, self._name,
                                  '_', str(self.get_rev())])
        if flag & BlobHandle.CREATE:
            if not flag & BlobHandle.WRITE:
                raise ValueError("invalid flag")
            else:
                self._need_commit = True
                self._createtag = True
                self._written = True
        if flag & BlobHandle.WRITE:
            self._tmpfile = self.gen_tmp()

    def __del__(self):
        self.del_tmp()
        self._blobclient.close(self)

    def create(self):
        self._create(self.location + self._name)
    
    def read(self, length, offset):
        if self._is_closed:
            raise Exception("This Blob is closed")
        if not self._flag & BlobHandle.READ:
            raise Exception("Permission Denied")
        return self._read(length, offset)

    def write(self, data, offset):
        if self._is_closed:
            raise Exception("This Blob is closed")
        if not self._flag & BlobHandle.WRITE:
            raise Exception("Permission Denied")
        self._need_commit = True
        written_bytes = self._write(data, offset)
        self._written = bool(written_bytes)
        self._info['size'] = self._get_size()
        return written_bytes

    def rename(self, newname):
        if self._is_closed:
            raise Exception("This Blob is closed")
        if not self._flag & BlobHandle.DELETE:
            raise Exception("Permission Denied")
        self._need_commit = True
        
    def delete(self, deltag=True):
        if self._is_closed:
            raise Exception("This Blob is closed")
        if not self._flag & BlobHandle.DELETE:
            raise Exception("Permission Denied")
        self._need_commit = True
        self._deltag = deltag

    def close(self):
        self._is_closed = True
        if self._flag != BlobHandle.READ:
            self._blobclient.close(self)

    def get_metadata(self):
        if self._is_closed:
            raise Exception("This Blob is closed")
        return self._info['metadata']

    def set_metadata(self, metadata):
        if self._is_closed:
            raise Exception("This Blob is closed")
        if not self._flag & BlobHandle.WRITEMETA:
            raise Exception("Permission Deniedd")
        self._info['metadata'] = metadata
        self._need_commit = True

    def get_rev(self):
        if self._is_closed:
            raise Exception("This Blob is closed")
        return self._info['rev']

    def get_container(self):
        if self._is_closed:
            raise Exception("This Blob is closed")
        return self._info['container']

    def get_size(self):
        if self._is_closed:
            raise Exception("This Blob is closed")
        return self._info['size']

    def commit(self, flag):
        if self._is_closed:
            raise Exception("This Blob is closed")
        if not self._need_commit:
            return False
        commit_info = dict()
        commit_info['blobname'] = self._name
        if self._deltag:
            commit_info['deltag'] = True
        else:
            commit_info['deltag'] = False
            commit_info['createtag'] = self._createtag
            commit_info['info'] = self._info
            commit_info['written'] = self._written
        return self._blobclient.commit(commit_info, flag, self)

    def copy_tmp(self):
        BlobHandle.copy_file(
            self._tmpfile,
            ''.join([self._location, self._info['container'], '_',
                     self._name, '_', str(self._info['rev'])])
        )
        pass

    @abstractmethod
    def gen_tmp(self):
        # return tmp file path
        pass

    @abstractmethod
    def del_tmp(self):
        pass

    @abstractmethod
    def _read(self, length, offset):
        pass

    @abstractmethod
    def _write(self, data, offset):
        pass

    @abstractmethod
    def _get_size(self):
        pass

    @staticmethod
    @abstractmethod
    def copy_file(source, dest):
        pass

    @staticmethod
    @abstractmethod
    def del_blob(blobpath):
        pass