diff --git a/start_vms.py b/start_vms.py
index 93162a3..62e4ca5 100644
--- a/start_vms.py
+++ b/start_vms.py
@@ -6,7 +6,7 @@
 
 from concurrent.futures import ThreadPoolExecutor
 
-# from novaclient.exceptions import NotFound
+from novaclient.exceptions import NotFound
 from novaclient.client import Client as n_client
 from cinderclient.v1.client import Client as c_client
 
@@ -45,7 +45,7 @@
         NOVA_CONNECTION = None
 
 
-def prepare_os(name=None, passwd=None, tenant=None, auth_url=None):
+def prepare_os_subpr(name=None, passwd=None, tenant=None, auth_url=None):
     if name is None:
         name, passwd, tenant, auth_url = ostack_get_creds()
 
@@ -58,24 +58,46 @@
 
     params_s = " ".join("{}={}".format(k, v) for k, v in params.items())
 
-    cmd = "env {params} bash scripts/prepare.sh".format(params_s)
+    cmd_templ = "env {params} bash scripts/prepare.sh >/dev/null"
+    cmd = cmd_templ.format(params=params_s)
     subprocess.call(cmd, shell=True)
 
-    return NOVA_CONNECTION
+
+def prepare_os(nova, params):
+    allow_ssh(nova, params['security_group'])
+
+    shed_ids = []
+    for shed_group in params['schedulers_groups']:
+        shed_ids.append(get_or_create_aa_group(nova, shed_group))
+
+    create_keypair(nova,
+                   params['keypair_name'],
+                   params['pub_key_path'],
+                   params['priv_key_path'])
+
+    create_image(nova, params['image']['name'],
+                 params['image']['url'])
+
+    create_flavor(nova, **params['flavor'])
 
 
-# def get_or_create_aa_group(nova, name):
-#     try:
-#         group = conn.server_groups.find(name=name)
-#     except NotFound:
-#         group = None
+def get_or_create_aa_group(nova, name):
+    try:
+        group = nova.server_groups.find(name=name)
+    except NotFound:
+        group = nova.server_groups.create({'name': name,
+                                           'policies': ['anti-affinity']})
 
-#     if group is None:
-#         conn.server_groups.create
+    return group.id
 
 
-def allow_ssh(nova):
-    secgroup = nova.security_groups.find(name="default")
+def allow_ssh(nova, group_name):
+    try:
+        secgroup = nova.security_groups.find(name=group_name)
+    except NotFound:
+        secgroup = nova.security_groups.create(group_name,
+                                               "allow ssh/ping to node")
+
     nova.security_group_rules.create(secgroup.id,
                                      ip_protocol="tcp",
                                      from_port="22",
@@ -87,11 +109,32 @@
                                      from_port=-1,
                                      cidr="0.0.0.0/0",
                                      to_port=-1)
+    return secgroup.id
 
 
-def create_keypair(nova, name, key_path):
-    with open(key_path) as key:
-        return nova.keypairs.create(name, key.read())
+def create_image(nova, name, url):
+    pass
+
+
+def create_flavor(nova, name, **params):
+    pass
+
+
+def create_keypair(nova, name, pub_key_path, priv_key_path):
+    try:
+        nova.keypairs.find(name=name)
+    except NotFound:
+        if os.path.exists(pub_key_path):
+            with open(pub_key_path) as pub_key_fd:
+                return nova.keypairs.create(name, pub_key_fd.read())
+        else:
+            key = nova.keypairs.create(name)
+
+            with open(priv_key_path, "w") as priv_key_fd:
+                priv_key_fd.write(key.private_key)
+
+            with open(pub_key_path, "w") as pub_key_fd:
+                pub_key_fd.write(key.public_key)
 
 
 def create_volume(size, name):
@@ -156,19 +199,30 @@
         srv_count = len([srv for srv in lst if srv.status == 'enabled'])
         count = srv_count * int(count[1:])
 
-    srv_params = "img: {img_name}, flavor: {flavor_name}".format(**params)
+    srv_params = "img: {image[name]}, flavor: {flavor[name]}".format(**params)
     msg_templ = "Will start {0} servers with next params: {1}"
     logger.info(msg_templ.format(count, srv_params))
     vm_creds = params.pop('creds')
 
+    params = params.copy()
+
+    params['img_name'] = params['image']['name']
+    params['flavor_name'] = params['flavor']['name']
+
+    del params['image']
+    del params['flavor']
+    del params['scheduler_group_name']
+    private_key_path = params.pop('private_key_path')
+
     for ip, os_node in create_vms_mt(NOVA_CONNECTION, count, **params):
-        yield Node(vm_creds.format(ip), []), os_node.id
+        conn_uri = vm_creds.format(ip=ip, private_key_path=private_key_path)
+        yield Node(conn_uri, []), os_node.id
 
 
 def create_vms_mt(nova, amount, keypair_name, img_name,
                   flavor_name, vol_sz=None, network_zone_name=None,
                   flt_ip_pool=None, name_templ='ceph-test-{0}',
-                  scheduler_hints=None):
+                  scheduler_hints=None, security_group=None):
 
     with ThreadPoolExecutor(max_workers=16) as executor:
         if network_zone_name is not None:
@@ -208,7 +262,7 @@
         for name, flt_ip in zip(names, ips):
             params = (nova, name, keypair_name, img, fl,
                       nics, vol_sz, flt_ip, scheduler_hints,
-                      flt_ip_pool)
+                      flt_ip_pool, [security_group])
 
             futures.append(executor.submit(create_vm, *params))
         res = [future.result() for future in futures]
@@ -220,12 +274,16 @@
               fl, nics, vol_sz=None,
               flt_ip=False,
               scheduler_hints=None,
-              pool=None):
+              pool=None,
+              security_groups=None):
     for i in range(3):
         srv = nova.servers.create(name,
-                                  flavor=fl, image=img, nics=nics,
+                                  flavor=fl,
+                                  image=img,
+                                  nics=nics,
                                   key_name=keypair_name,
-                                  scheduler_hints=scheduler_hints)
+                                  scheduler_hints=scheduler_hints,
+                                  security_groups=security_groups)
 
         if not wait_for_server_active(nova, srv):
             msg = "Server {0} fails to start. Kill it and try again"
@@ -276,13 +334,16 @@
             nova.servers.delete(srv)
             deleted_srvs.add(srv.id)
 
-    while deleted_srvs != set():
-        logger.debug("Waiting till all servers are actually deleted")
+    count = 0
+    while True:
+        if count % 60 == 0:
+            logger.debug("Waiting till all servers are actually deleted")
         all_id = set(srv.id for srv in nova.servers.list())
-        if all_id.intersection(deleted_srvs) == set():
-            logger.debug("Done, deleting volumes")
+        if len(all_id.intersection(deleted_srvs)) == 0:
             break
+        count += 1
         time.sleep(1)
+    logger.debug("Done, deleting volumes")
 
     # wait till vm actually deleted