Archipelago

    FIRST_COLUMN_WIDTH,

    SECOND_COLUMN_WIDTH,

    ctext,

    pretty_print,

    loaded_module,

    load_module,

    config,

    peers,

    Error,

)

from vlmc import showmapped as vlmc_showmapped

from vlmc import get_mapped as vlmc_get_mapped

def start(user=False, role=None, cli=False, **kwargs):

    if role:

        try:

            p = peers[role]

        return start_peer(p, cli)

    if user:

        start_peers(peers, cli)

        mapped = vlmc_get_mapped()

        if mapped:

        print "===================="

        print ""

    try:

        #time.sleep(0.5)

        start_peers(peers, cli)

        load_module("blktap", None)

def stop(user=False, role=None, cli=False, **kwargs):

    if role:

        try:

            p = peers[role]

                if not VlmcTapdisk.is_paused(m.device):

                    VlmcTapdisk.pause(m.device)

        stop_peers(peers, cli)

    #check devices

    if cli:

        print "===================="

    if not loaded_module("blktap"):

        stop_peers(peers, cli)

        time.sleep(0.5)

        return

    if cli:

            raise Error("Cannot stop archipelago. Mapped volumes exist")

    stop_peers(peers, cli)

    time.sleep(0.5)

def status(cli=False, **kwargs):

    r = 0

    if not loaded_module("blktap"):

        for role, _ in reversed(config['roles']):

            p = peers[role]

import sys

import argparse

from common import (

    ctext,

    Error,

)

    try:

        args = parser.parse_args()

        kwargs = vars(args)

        # if parser_func == archipelago_parser:

            # peers = construct_peers()

valid_segment_types = ['posix']

peers = dict()

BIN_DIR = '/usr/bin/'

DEFAULTS = '/etc/archipelago/archipelago.conf'

        return ctx

    port_ranges = []

    def isExec(file_path):

        port_ranges.append((portno_start, portno_end))

    try:

        if not config['roles']:

            raise Error("Roles setup must be provided")

        else:

            raise Error("No valid peer type: %s" % role_type)

        validatePortRange(peers[role].portno_start, peers[role].portno_end,

    return True

def construct_peers():

    for r in roles:

        config[r] = createDict(cfg, r)

def loaded_modules():

    lines = open("/proc/modules").read().split("\n")

        size = size << 20

    ret = False

    mport = peers['mapperd'].portno_start

    req = Request.get_clone_request(xseg_ctx, mport, snap, clone=name,

                                    clone_size=size, cont_addr=cont_addr)

    if len(name) < 6:

        raise Error("Name should have at least len 6")

    vport = peers['vlmcd'].portno_start

    req = Request.get_snapshot_request(xseg_ctx, vport, name, snap=snap_name)

    req.submit()

    if len(name) < 6:

        raise Error("Name should have at least len 6")

    mport = peers['mapperd'].portno_start

    req = Request.get_hash_request(xseg_ctx, mport, name)

    req.submit()

                    device))

    ret = False

    mport = peers['mapperd'].portno_start

    req = Request.get_delete_request(xseg_ctx, mport, name)

    req.submit()

    name = ARCHIP_PREFIX + name

    mbport = peers['blockerm'].portno_start

    req = Request.get_acquire_request(xseg_ctx, mbport, name)

    req.submit()

    name = ARCHIP_PREFIX + name

    mbport = peers['blockerm'].portno_start

    req = Request.get_release_request(xseg_ctx, mbport, name, force=force)

    req.submit()

        raise Error("Name should have at least len 6")

    ret = False

    vport = peers['vlmcd'].portno_start

    req = Request.get_open_request(xseg_ctx, vport, name)

    req.submit()

        raise Error("Name should have at least len 6")

    ret = False

    vport = peers['vlmcd'].portno_start

    req = Request.get_close_request(xseg_ctx, vport, name)

    req.submit()

        raise Error("Name should have at least len 6")

    ret = False

    mport = peers['mapperd'].portno_start

    req = Request.get_info_request(xseg_ctx, mport, name)

    req.submit()