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