def account_user_create(): username = current_user.username _user_account = request.json['user_account'] print 'account_user_create locals:', dict(locals()) # create user account username_ = _user_account['username'] _user_account['created'] = _user_account['updated'] = datetime.utcnow() user_account = UserAccount(**_user_account) db.session.add(user_account) # create user quota user_quota = UserQuota(username=username_) db.session.add(user_quota) # create user stat user_stat = UserStat(username=username_) db.session.add(user_stat) # commit db.session.commit() _user_account = object_to_dict(user_account) data = { 'user_account': _user_account, } return jsonify(data)
def volume_update(): username = current_user.username usertype = current_user.usertype _volume = request.json['volume'] print 'volume_update:', locals() # FIXME: if usertype != 'super': data = {} return jsonify(data) volume = Volume.query.get(_volume['id']) _volume['updated'] = datetime.utcnow() update_object_with_dict(volume, _volume) db.session.commit() _volume = object_to_dict(volume) # insert host_name # insert mount_point_name host = Host.query.get(_volume['host_id']) assert host is not None mount_point = MountPoint.query.get(_volume['mount_point_id']) assert mount_point is not None _volume['host_name'] = host.name _volume['mount_point_name'] = mount_point.name data = { 'volume': _volume, } return jsonify(data)
def mount_update(): username = current_user.username usertype = current_user.usertype _mount = request.json['mount'] print 'mount_update:', locals() # FIXME: if usertype != 'super': data = {} return jsonify(data) mount = MountPoint.query.get(_mount['id']) _mount['updated'] = datetime.utcnow() update_object_with_dict(mount, _mount) db.session.commit() _mount = object_to_dict(mount) # insert host_name host = Host.query.get(_mount['host_id']) assert host is not None _mount['host_name'] = host.name data = { 'mount': _mount, } return jsonify(data)
def volume_volumes(): username = current_user.username print 'volume_volumes:', locals() # get user account properties user_account = UserAccount.query.filter_by(username=username).one() dct = object_to_dict(user_account) return render_template('volume-volumes.html', **dct)
def host_hosts(): username = current_user.username print 'host_hosts:', locals() # get user account properties user_account = UserAccount.query.filter_by(username=username).one() dct = object_to_dict(user_account) return render_template( 'host-hosts.html', **dct )
def network_domains(): username = current_user.username print 'network_domains:', locals() # get user account properties user_account = UserAccount.query.filter_by(username=username).one() dct = object_to_dict(user_account) return render_template( 'network-domains.html', **dct )
def container_containers(): username = current_user.username print 'container_containers:', locals() # get user account properties user_account = UserAccount.query.filter_by(username=username).one() dct = object_to_dict(user_account) return render_template( 'container-containers.html', **dct )
def account_quota_get(): username = current_user.username usertype = current_user.usertype username_ = request.json['username'] print 'account_quota_get locals:', dict(locals()) # get query user_quota = UserQuota.query.filter_by(username=username_).one() _user_quota = object_to_dict(user_quota) data = { 'user_quota': _user_quota, } return jsonify(data)
def account_stat_get(): username = current_user.username usertype = current_user.usertype username_ = request.json['username'] print 'account_stat_get locals:', dict(locals()) # get stat user_stat = UserStat.query.filter_by(username=username_).one() _user_stat = object_to_dict(user_stat) data = { 'user_stat': _user_stat, } return jsonify(data)
def account_user_update(): username = current_user.username _user_account = request.json['user_account'] print 'account_user_update locals:', dict(locals()) # update user account username_ = _user_account['username'] user_account = UserAccount.query.filter_by(username=username_).one() _user_account['updated'] = datetime.utcnow() update_object_with_dict(user_account, _user_account) db.session.commit() _user_account = object_to_dict(user_account) data = { 'user_account': _user_account, } return jsonify(data)
def account_quota_update(): username = current_user.username usertype = current_user.usertype _user_quota = request.json['user_quota'] print 'account_quota_update locals:', dict(locals()) # update user quota user_quota = UserQuota.query.filter_by(username=_user_quota['username']).one() _user_quota['updated'] = datetime.utcnow() update_object_with_dict(user_quota, _user_quota) db.session.commit() _user_quota = object_to_dict(user_quota) data = { 'user_quota': _user_quota, } return jsonify(data)
def network_domain_create(): username = current_user.username usertype = current_user.usertype _domain = request.json['domain'] print 'network_domain_create:', locals() if usertype != 'super': data = {} return jsonify(data) _domain['created'] = _domain['updated'] = datetime.utcnow() domain = Domain(**_domain) db.session.add(domain) db.session.commit() _domain = object_to_dict(domain) data = { 'domain': _domain, } return jsonify(data)
def network_domain_update(): username = current_user.username usertype = current_user.usertype _domain = request.json['domain'] print 'network_domain_update:', locals() if usertype != 'super': data = {} return jsonify(data) domain = Domain.query.get(_domain['id']) _domain['updated'] = datetime.utcnow() update_object_with_dict(domain, _domain) db.session.commit() _domain = object_to_dict(domain) data = { 'domain': _domain, } return jsonify(data)
def network_route_update(): username = current_user.username usertype = current_user.usertype _route = request.json['route'] print 'network_route_update:', locals() if usertype != 'super': data = {} return jsonify(data) route = Route.query.get(_route['id']) _route['updated'] = datetime.utcnow() update_object_with_dict(route, _route) db.session.commit() _route = object_to_dict(route) # insert domain, host, container name domain = Domain.query.get(_route['domain_id']) assert domain is not None host = Host.query.get(_route['host_id']) assert host is not None container = Container.query.get(_route['container_id']) assert container is not None _route['domain_domain'] = domain.domain _route['host_name'] = host.name _route['container_name'] = container.name _route['container_container_id'] = container.container_id data = { 'route': _route, } return jsonify(data)
def host_update(): username = current_user.username usertype = current_user.usertype _host = request.json['host'] print 'host_update:', locals() if usertype != 'super': data = {} return jsonify(data) host = Host.query.get(_host['id']) assert host is not None _host['updated'] = datetime.utcnow() update_object_with_dict(host, _host) db.session.commit() _host = object_to_dict(host) data = { 'host': _host, } return jsonify(data)
def mount_create(): username = current_user.username usertype = current_user.usertype _mount = request.json['mount'] print 'mount_add:', locals() # FIXME: if usertype != 'super': data = {} return jsonify(data) # try to find range patterns if 'host' in _mount: name = _mount['name'] ranges = list(re.findall('\[\w+\-\w+\]', name)) else: ranges = None if ranges: # generate all combinations patterns = list(ranges) ranges = [r.strip('[]').split('-') for r in ranges] for i, r in enumerate(ranges): s, e = r if s.isdigit() and e.isdigit(): s, e = map(int, r) r = range(s, e + 1) ranges[i] = r else: # FIXME: support alpha-num ranges for multi-character strings # with same size assert len(s) == len(e) == 1 s, e = map(ord, r) r = range(s, e + 1) r = map(chr, r) r = ''.join(r) ranges[i] = r combs = [map(str, c) for c in product(*ranges)] # generate mount points host = _mount['host'] device = _mount['device'] mountpoint = _mount['mountpoint'] filesystem = _mount['filesystem'] capacity = _mount['capacity'] mounts = [] _mounts = [] for comb in combs: _host = host _name = name _device = device _mountpoint = mountpoint _filesystem = filesystem _capacity = capacity for p, c in zip(patterns, comb): _host = _host.replace(p, c) _name = _name.replace(p, c) _device = _device.replace(p, c) _mountpoint = _mountpoint.replace(p, c) _filesystem = _filesystem.replace(p, c) _capacity = _capacity.replace(p, c) host_ = Host.query.filter_by(name=_host).one() assert host_ is not None _host_id = host_.id __mount = { 'host_id': _host_id, 'name': _name, 'device': _device, 'mountpoint': _mountpoint, 'filesystem': _filesystem, 'capacity': _capacity, } __mount['created'] = __mount['updated'] = datetime.utcnow() mount = MountPoint(**__mount) db.session.add(mount) mounts.append(mount) db.session.commit() for mount in mounts: __mount = object_to_dict(mount) # insert host_name host_ = Host.query.get(__mount['host_id']) assert host_ is not None __mount['host_name'] = host_.name _mounts.append(__mount) data = { 'mounts': _mounts, } else: _mount['created'] = _mount['updated'] = datetime.utcnow() mount = MountPoint(**_mount) db.session.add(mount) db.session.commit() _mount = object_to_dict(mount) # insert host_name host = Host.query.get(_mount['host_id']) assert host is not None _mount['host_name'] = host.name data = { 'mount': _mount, } return jsonify(data)
def image_create(): username = current_user.username usertype = current_user.usertype _image = request.json['image'] print 'image_add:', locals() # FIXME: if usertype != 'super': data = {} return jsonify(data) _image['status'] = 'downloading' _image['created'] = _image['updated'] = datetime.utcnow() image = Image(**_image) db.session.add(image) db.session.commit() _image = object_to_dict(image) ## # "async" create/pull image def _requests_post(*args, **kwargs): try: r = requests.post(*args, **kwargs) print r assert r.status_code == 200 except requests.exceptions.ChunkedEncodingError as e: print e def _image_create(): # get all hosts hosts = Host.query.all() threads = [] for host in hosts: # create volume at host url = 'http://%s:%i/images/create?fromImage=%s' % ( host.host, host.port, _image['name'], ) data_ = json.dumps({}) headers = {'content-type': 'application/json'} auth = HTTPBasicAuth(host.auth_username, host.auth_password) t = Thread(target=_requests_post, args=(url, ), kwargs=dict(data=data_, headers=headers, auth=auth)) threads.append(t) t.start() for t in threads: t.join() session = db.create_scoped_session() image = session.query(Image).get(_image['id']) image.status = 'ready' session.commit() mt = Thread(target=_image_create) mt.start() ## # insert host_name host = Host.query.get(_image['host_id']) if host: _image['host_name'] = host.name else: _image['host_name'] = 'ALL' data = { 'image': _image, } return jsonify(data)
def container_create(): username = current_user.username usertype = current_user.usertype _container = request.json['container'] print 'container_add:', locals() # FIXME: if usertype != 'super': data = {} return jsonify(data) # unpack _host_id = _container.get('host_id', None) _name = _container['name'] _image_id = _container['image_id'] _command = _container['command'] _volumes = _container.get('volumes', []) _volumes_from = _container.get('volumes_from', []) _env_vars = _container['env_vars'] _expose_ports = _container['expose_ports'] _publish_ports = _container['publish_ports'] _link_containers = _container.get('link_containers', []) _ram_limit = _container['ram_limit'] _n_cpu_cores = _container['n_cpu_cores'] # find suitable volume according to host if not _host_id and not _volumes: hosts = Host.query.all() host = random.choice(hosts) _host_id = host.id _host_host = host.host _volume_names = [] elif not _host_id and _volumes: assert len(_volumes) == 1 _volume_id = _volumes[0] volume = Volume.query.get(_volume_id) _volume_names = [volume.perm_name] host = Host.query.get(volume.host_id) _host_id = host.id _host_host = host.host else: host = Host.query.get(_host_id) _host_host = host.host _volume_names = [] # find image name image = Image.query.get(_image_id) _image_name = image.name _volumes = json.dumps(_volumes) _volumes_from = json.dumps(_volumes_from) _link_containers = json.dumps(_link_containers) ## # create docker container url = 'http://%s:%i/containers/create' % (host.host, host.port) data_ = json.dumps({ "Hostname": _host_host, "User": "", "Memory": _ram_limit, "MemorySwap": 0, "AttachStdin": True, "AttachStdout": True, "AttachStderr": True, "PortSpecs": None, "Tty": False, "OpenStdin": False, "StdinOnce": False, "Env": _env_vars, "Cmd": [_command], "Image": _image_name, "Volumes": {v: {} for v in _volume_names}, "WorkingDir": "", "DisableNetwork": False, "ExposedPorts": {p: {} for p in _publish_ports.strip('\t ').split(',')}, }) print data_ headers = { 'content-type': 'application/json', } auth = HTTPBasicAuth(host.auth_username, host.auth_password) r = requests.post(url, data=data_, headers=headers, auth=auth) print r assert r.status_code == 200 container_id = r.json()['Id'] ## # insert container into database _status = 'ready' __container = { 'host_id': _host_id, 'name': _name, 'image_id': _image_id, 'command': _command, 'volumes': _volumes, 'volumes_from': _volumes_from, 'env_vars': _env_vars, 'expose_ports': _expose_ports, 'publish_ports': _publish_ports, 'link_containers': _link_containers, 'ram_limit': _ram_limit, 'n_cpu_cores': _n_cpu_cores, 'cpu_share': _cpu_share, 'status': _status, } __container['username'] = username __container['container_id'] = container_id __container['created'] = __container['updated'] = datetime.utcnow() __container['perm_name'] = '%s_%s' % ( __container['username'], __container['name'], ) container = Container(**__container) db.session.add(container) db.session.commit() __container = object_to_dict(container) # insert host_name host = Host.query.get(__container['host_id']) __container['host_name'] = host.name if host else 'ALL' # insert image_name image = Image.query.get(__container['image_id']) __container['image_name'] = image.name data = { 'container': __container, } return jsonify(data)
def volume_create(): username = current_user.username usertype = current_user.usertype _volume = request.json['volume'] print 'volume_add:', locals() # FIXME: if usertype != 'super': data = {} return jsonify(data) host_id = _volume.get('host_id', None) mount_point_id = _volume.get('mount_point_id', None) name = _volume['name'] capacity = _volume['capacity'] username_ = _volume['username'] # find available host and/or mount point if host_id is None or mount_point_id is None: query = MountPoint.query if host_id is not None and mount_point_id is None: query = query.filter_by(host_id=host_id) mount_points = query.all() mount_points = [ m for m in mount_points if m.capacity - m.reserved >= capacity ] # no mount_points available if not mount_points: data = { 'error': 'The is no available space.'\ 'Try smaller volume capacity than %s GB.' % capacity, } return jsonify(data) # take first available slice mount_points.sort(key=lambda m: m.capacity - m.reserved) mount_point = random.choice(mount_points) # host, mount_point host_id = mount_point.host_id mount_point_id = mount_point.id # host_name host = Host.query.get(host_id) assert host is not None # mount_point_name mount_point = MountPoint.query.get(mount_point_id) assert mount_point is not None if mount_point.capacity - mount_point.reserved < capacity: data = { 'error': 'The is no available space.'\ 'Try smaller volume capacity than %s GB.' % capacity, } return jsonify(data) # increase reserved storage at mount point mount_point.reserved = mount_point.reserved + capacity # insert volume into database __volume = { 'host_id': host_id, 'mount_point_id': mount_point_id, 'name': name, 'capacity': capacity, 'username': username_, } __volume['created'] = __volume['updated'] = datetime.utcnow() __volume['perm_name'] = perm_name = '%s_%s' % (username_, uuid.uuid4().hex) volume = Volume(**__volume) db.session.add(volume) ## # create volume at host url = 'http://%s:%i/dockyard/volume/create' % (host.host, host.port) data_ = json.dumps({ 'mountpoint': mount_point.mountpoint, 'name': perm_name, 'size': capacity, }) headers = { 'content-type': 'application/json', } auth = HTTPBasicAuth(host.auth_username, host.auth_password) r = requests.post(url, data=data_, headers=headers, auth=auth) assert r.status_code == 200 ## db.session.commit() # return response __volume = object_to_dict(volume) # insert host_name # insert mount_point_name __volume['host_name'] = host.name __volume['mount_point_name'] = mount_point.name data = { 'volume': __volume, } return jsonify(data)
def host_create(): username = current_user.username usertype = current_user.usertype _host = request.json['host'] print 'host_add:', locals() if usertype != 'super': data = {} return jsonify(data) name = _host['name'] host = _host['host'] port = _host['port'] auth_username = _host['auth_username'] auth_password = _host['auth_password'] ram_capacity = _host['ram_capacity'] ram_reserved = _host['ram_reserved'] if '[' in name and '-' in name and ']' in name and \ '[' in host and '-' in host and ']' in host: _hosts = [] hosts = [] # name base/range s = name.find('[') e = name.find(']') name_base = name[:s] name_range = name[s + 1:e] name_range = name_range.strip(' ').strip() name_range = map(int, name_range.split('-')) name_range[1] += 1 # host base/range s = host.find('[') e = host.find(']') host_base = host[:s] host_range = host[s + 1:e] host_range = host_range.strip(' ').strip() host_range = map(int, host_range.split('-')) host_range[1] += 1 for i, j in zip(range(*name_range), range(*host_range)): __host = { 'name': '%s%i' % (name_base, i), 'host': '%s%i' % (host_base, j), 'port': port, 'auth_username': auth_username, 'auth_password': auth_password, 'ram_capacity': ram_capacity, 'ram_reserved': ram_reserved, } __host['created'] = __host['updated'] = datetime.utcnow() host = Host(**__host) db.session.add(host) hosts.append(host) db.session.commit() for host in hosts: __host = object_to_dict(host) _hosts.append(__host) data = { 'hosts': _hosts, } else: _host['created'] = _host['updated'] = datetime.utcnow() host = Host(**_host) db.session.add(host) db.session.commit() _host = object_to_dict(host) data = { 'host': _host, } return jsonify(data)