github.com/yasker/longhorn-engine@v0.0.0-20160621014712-6ed6cfca0729/integration/data/common.py (about) 1 import random 2 import string 3 import base64 4 import subprocess 5 6 import os 7 from os import path 8 9 import pytest 10 import cattle 11 12 REPLICA1 = 'tcp://localhost:9502' 13 REPLICA1_SCHEMA = 'http://localhost:9502/v1/schemas' 14 REPLICA2 = 'tcp://localhost:9505' 15 REPLICA2_SCHEMA = 'http://localhost:9505/v1/schemas' 16 17 BACKED_REPLICA1 = 'tcp://localhost:9602' 18 BACKED_REPLICA1_SCHEMA = 'http://localhost:9602/v1/schemas' 19 BACKED_REPLICA2 = 'tcp://localhost:9605' 20 BACKED_REPLICA2_SCHEMA = 'http://localhost:9605/v1/schemas' 21 22 SIZE = 1024 * 4096 23 24 BACKUP_DIR = '/tmp/longhorn-backup' 25 BACKUP_DEST = 'vfs://' + BACKUP_DIR 26 27 BACKING_FILE = 'backing_file.raw' 28 29 30 def _file(f): 31 return path.join(_base(), '../../{}'.format(f)) 32 33 34 def _base(): 35 return path.dirname(__file__) 36 37 38 @pytest.fixture() 39 def dev(request): 40 prepare_backup_dir(BACKUP_DIR) 41 controller = controller_client(request) 42 replica = replica_client(request, REPLICA1_SCHEMA) 43 replica2 = replica_client(request, REPLICA2_SCHEMA) 44 45 open_replica(replica) 46 open_replica(replica2) 47 48 replicas = controller.list_replica() 49 assert len(replicas) == 0 50 51 v = controller.list_volume()[0] 52 v = v.start(replicas=[ 53 REPLICA1, 54 REPLICA2 55 ]) 56 assert v.replicaCount == 2 57 d = get_restdev() 58 59 return d 60 61 62 @pytest.fixture() 63 def backing_dev(request): 64 prepare_backup_dir(BACKUP_DIR) 65 controller = controller_client(request) 66 replica = replica_client(request, BACKED_REPLICA1_SCHEMA) 67 replica2 = replica_client(request, BACKED_REPLICA2_SCHEMA) 68 69 open_replica(replica) 70 open_replica(replica2) 71 72 replicas = controller.list_replica() 73 assert len(replicas) == 0 74 75 v = controller.list_volume()[0] 76 v = v.start(replicas=[ 77 BACKED_REPLICA1, 78 BACKED_REPLICA2 79 ]) 80 assert v.replicaCount == 2 81 d = get_restdev() 82 83 return d 84 85 86 def controller_client(request): 87 url = 'http://localhost:9501/v1/schemas' 88 c = cattle.from_env(url=url) 89 request.addfinalizer(lambda: cleanup_controller(c)) 90 c = cleanup_controller(c) 91 assert c.list_volume()[0].replicaCount == 0 92 return c 93 94 95 def cleanup_controller(client): 96 for r in client.list_replica(): 97 client.delete(r) 98 return client 99 100 101 def replica_client(request, url): 102 c = cattle.from_env(url=url) 103 request.addfinalizer(lambda: cleanup_replica(c)) 104 return cleanup_replica(c) 105 106 107 def cleanup_replica(client): 108 r = client.list_replica()[0] 109 if r.state == 'initial': 110 return client 111 if 'open' in r: 112 r = r.open() 113 client.delete(r) 114 r = client.reload(r) 115 assert r.state == 'initial' 116 return client 117 118 119 def open_replica(client, backing_file=None): 120 replicas = client.list_replica() 121 assert len(replicas) == 1 122 123 r = replicas[0] 124 assert r.state == 'initial' 125 assert r.size == '0' 126 assert r.sectorSize == 0 127 assert r.parent == '' 128 assert r.head == '' 129 130 r = r.create(size=str(1024 * 4096)) 131 132 assert r.state == 'closed' 133 assert r.size == str(1024 * 4096) 134 assert r.sectorSize == 512 135 assert r.parent == '' 136 assert r.head == 'volume-head-000.img' 137 138 return r 139 140 141 def get_restdev(): 142 url = 'http://localhost:9414/v1/schemas' 143 c = cattle.from_env(url=url) 144 dev = c.list_volume()[0] 145 assert dev.name == "test-volume" 146 return dev 147 148 149 def write_dev(dev, offset, data): 150 l = len(data) 151 encoded_data = base64.encodestring(data) 152 dev.write(offset=offset, length=l, data=encoded_data) 153 154 155 def read_dev(dev, offset, length): 156 data = dev.read(offset=offset, length=length)["data"] 157 return base64.decodestring(data) 158 159 160 def random_string(length): 161 return ''.join(random.choice(string.lowercase) for x in range(length)) 162 163 164 def verify_data(dev, offset, data): 165 write_dev(dev, offset, data) 166 readed = read_dev(dev, offset, len(data)) 167 assert data == readed 168 169 170 def prepare_backup_dir(backup_dir): 171 if os.path.exists(backup_dir): 172 subprocess.check_call(["rm", "-rf", backup_dir]) 173 174 os.makedirs(backup_dir) 175 assert os.path.exists(backup_dir) 176 177 178 def read_from_backing_file(offset, length): 179 p = _file(BACKING_FILE) 180 assert path.exists(p) 181 f = open(p, 'r') 182 f.seek(offset) 183 data = f.read(length) 184 f.close() 185 return data