def test_strre_value(self):
schema = Schema(StrRe("^(abc|efg)$"))
self.assertEquals("abc", schema.validate("abc"))
self.assertEquals("efg", schema.validate("efg"))
with self.assertRaises(SchemaError):
schema.validate("ebc")
with self.assertRaises(SchemaError):
schema.validate("abcdefg")
with self.assertRaises(SchemaError):
schema.validate(0)
with self.assertRaises(SchemaError):
schema.validate(1)
vgs = lvm_mng.get_all_vg()
vg_dict = []
for vg in vgs:
vg_info = {
'name': vgs[vg].name,
'uuid': vgs[vg].uuid,
'size': vgs[vg].size,
'free_size': vgs[vg].free_size,
}
vg_dict.append(vg_info)
return vg_dict
new_vg_schema = Schema({
"vgname":
StrRe(r"^([a-zA-Z].+)$"),
"dev":
Default(ListVal(StrRe(r"^(/dev/sd[a-z]|/dev/md.+)$")), default=[]),
DoNotCare(Use(str)):
object # for all those key we don't care
})
#curl -v -X POST -d vgname=vg1 -d dev=/dev/sdb,/dev/sdc http://192.168.1.123:6543/storlever/api/v1/block/lvm/vg_list
#enable eth* or disable eth*
@post_view(route_name='vg_list')
def create_vg(request):
lvm_mng = lvm.lvm_mgr()
params = get_params_from_request(request, new_vg_schema)
vg = lvm_mng.new_vg(params['vgname'], params['dev'])
port_info = get_port_info(netif_info)
return port_info
#/network/eth_list/{port_name}/stat
@get_view(route_name='port_stat')
def get_port_stat(request):
port_name = request.matchdict['port_name']
eth_face = ifmgr.if_mgr()
netif_info = eth_face.get_interface_by_name(port_name)
stat_info = netif_info.statistic_info
return stat_info
port_mod_schema = Schema({
Optional("ip"): StrRe(r"^(|\d+\.\d+\.\d+\.\d+)$"), # ip addr
Optional("netmask"): StrRe(r"^(|\d+\.\d+\.\d+\.\d+)$"), # netmask addr
Optional("gateway"): StrRe(r"^(|\d+\.\d+\.\d+\.\d+)$"), # gateway addr
DoNotCare(Use(str)): object # for all those key we don't care
})
#curl -v -X PUT -d ip=192.168.0.222 -d gateway=192.168.1.1 -d netmask=255.255.0.0 http://192.168.1.123:6543/storlever/api/v1/network/eth_list/eth0
@put_view(route_name='single_port')
def modify_single_port(request):
port_info = get_params_from_request(request, port_mod_schema)
port_name = request.matchdict['port_name']
eth_face = ifmgr.if_mgr()
eth = eth_face.get_interface_by_name(port_name)
eth.set_ip_config(ip=port_info.get("ip", None),
netmask=port_info.get("netmask", None),
'tgt_target_lun_info',
'/san/tgt/target_list/{target_iqn}/lun_list/{lun_number}')
@get_view(route_name='tgt_conf')
def get_tgt_conf(request):
tgt_mgr = tgtmgr.TgtManager
return tgt_mgr.get_tgt_conf()
tgt_conf_schema = Schema({
# Define iscsi incoming discovery authentication setting. If it is
# empty, no authentication is performed. The format is username:passwd
Optional("incomingdiscoveryuser"):
StrRe(r"^(|\w+:\w+)$"),
# Define iscsi outgoing discovery authentication setting. If it is
# empty, no authentication is performe The format is username:passwd
Optional("outgoingdiscoveryuser"):
StrRe(r"^(|\w+:\w+)$"),
DoNotCare(Use(str)):
object # for all other key we don't care
})
@put_view(route_name='tgt_conf')
def put_tgt_conf(request):
tgt_mgr = tgtmgr.TgtManager
tgt_conf = get_params_from_request(request, tgt_conf_schema)
tgt_mgr.set_tgt_conf(tgt_conf, operator=request.client_addr)
return mds_dict
#http://192.168.1.10:6543/storlever/api/v1/block/md_list/name
@get_view(route_name='md')
def get_md_rest(request):
md_mgr = md.md_mgr()
mds = md_mgr.get_all_md()
name = request.matchdict['md_name']
md_inf = mds.get_md(name)
return md_inf
add_md_schema = Schema({
"name":
StrRe(r"^(.+)$"),
"level":
Or(1, 0, 5, 10, 6),
"dev":
Default(ListVal(StrRe(r"^(/dev/sd[a-z]|/dev/xvd.+)$")), default=[]),
DoNotCare(Use(str)):
object # for all those key we don't care
})
#curl -v -X POST -d name=test -d dev=/dev/sdb,/dev/sdc -d level=1 http://192.168.1.2:6543/storlever/api/v1/block/md_list
@post_view(route_name='md_list')
def add_md_rest(request):
md_mgr = md.md_mgr()
mds = md_mgr.get_all_md()
params = get_params_from_request(request, add_md_schema)
'/fs/list/{fsname}/quota_user') #get post
config.add_route('quota_user',
'/fs/list/{fsname}/quota_user/{user_name}') #put dete
config.add_route('share_list', '/fs/fs_list/{fs}/share_list')
#http://192.168.1.2:6543/storlever/api/v1/fs/type_list
@get_view(route_name='type_list')
def get_fs_type_list(request):
fs_mrg = fsmgr.fs_mgr()
type_list = fs_mrg.fs_type_list()
return type_list
mk_fs_schema = Schema({
"type": StrRe(r"^([a-zA-Z].+)$"),
"dev": StrRe(r"^(/dev/.+)$"),
Optional("options"): Default(StrRe(), default=""),
DoNotCare(Use(str)): object # for all those key we don't care
})
#curl -v -X POST -d type=ext4 -d dev=/dev/mapper/vg1-lv http://192.168.1.2:6543/storlever/api/v1/fs/mkfs
@post_view(route_name='mkfs')
def mk_fs(request):
fs_mrg = fsmgr.fs_mgr()
params = get_params_from_request(request, mk_fs_schema)
fs_mrg.mkfs_on_dev(params["type"], params["dev"], params["options"])
return Response(status=200)
config.add_route('snmp_agent_monitor_info',
'/utils/snmp_agent/monitor_list/{monitor_name}')
config.add_route('snmp_agent_trap_sink_list',
'/utils/snmp_agent/trap_sink_list')
@get_view(route_name='ntp_server_list')
def get_ntp_server_list(request):
ntp_mgr = ntpmgr.NtpManager
return ntp_mgr.get_server_conf_list()
ntp_server_list_schema = Schema([{
# it can be a ipv4 address, ipv6 address, or host dns name
"server_addr":
StrRe(r"^\S+$"),
# if set to True, it would be forced to resolve the host name to
# ipv6 address in DNS resolution
Optional("ipv6"):
Default(BoolVal(), default=False),
# Marks the server as preferred. All other things being equal,
# this host will be chosen for synchronization among set of correctly operating hosts
Optional("prefer"):
Default(BoolVal(), default=False),
# Specifies a mode number which is interpreted in a device
# specific fashion. For instance, it selects a dialing,
# protocol in the ACTS driver and a device subtype in the
# parse drivers.
# Only valid for reference clock server, i.e. server_addr is 127.127.t.n
block_info = block_mgr.get_block_dev_by_name(block_name)
block = {
'name':block_info.name,
'major':block_info.major,
'minor':block_info.minor,
'size':block_info.size,
'type':block_info.type,
'readonly':block_info.readonly,
'fs_type':block_info.fs_type,
'mount_point':block_info.mount_point
}
return block
block_clean_meta_schema = Schema({
Optional("opt"): StrRe(r"^(clean_meta|flush_buf)$"),
DoNotCare(Use(str)): object # for all those key we don't care
})
# curl -v -X put -d opt=clean_meta 'http://192.168.1.123:6543/storlever/api/v1/block/block_list/sdb'
@put_view(route_name='block')
def block_clean_meta(request):
block_name = request.matchdict['block']
params = get_params_from_request(request, block_clean_meta_schema)
if params['opt'] == "clean_meta":
block_mgr = blockmgr.block_mgr()
block_dev = block_mgr.get_block_dev_by_name(block_name)
block_dev.clean_meta()
elif params['opt'] == "flush_buf":
block_mgr = blockmgr.block_mgr()
block_dev = block_mgr.get_block_dev_by_name(block_name)
cfg_mgr = cfgmgr.cfg_mgr() # get cfg manager
cfg_mgr.restore_from_file(params["file"], user=request.client_addr)
return Response(status=200)
@get_view(route_name='selinux_state')
def get_selinux_state(request):
sys_mgr = sysinfo.sys_mgr() # get sys manager
return {"state": sys_mgr.get_selinux_state()}
selinux_mod_schema = Schema({
"state":
Default(StrRe(r"^(enforcing|permissive|disabled)$"), default="permissive"),
DoNotCare(Use(str)):
object # for all those key we don't care
})
@put_view(route_name='selinux_state')
def put_selinux_state(request):
params = get_params_from_request(request, selinux_mod_schema)
sys_mgr = sysinfo.sys_mgr() # get sys manager
sys_mgr.set_selinux_state(params['state'], user=request.client_addr)
return "System should be reboot when selinux state is changed"
@get_view(route_name='module_list')
def get_module_list(request):
Optional("write_enable"):
BoolVal(),
# When enabled, local users are allowed to log into the system
Optional("local_enable"):
BoolVal(),
# Only valid when local_enable is true. If userlist_enable == False,
# all local user (except for some reserved user, like root, bin) can login ftp.
# Otherwise, only the users, who is in the user list and is login enabled, can
# login ftp
Optional("userlist_enable"):
BoolVal(),
# Specifies the directory ftpd changes to after a local user logs in. default is
# empty, which means the user's home directory
Optional("local_root"):
StrRe(r"^\S*$"),
# When enabled, local users are change-rooted to their home directories after logging in.
Optional("chroot_enable"):
BoolVal(),
# Only valid when chroot_enable is true. If chroot_list == False,
# all local user are placed in a chroot jail upon log in.
# Otherwise, only the users, who is in the user list and is chroot enabled, would be
# placed in a chroot jail upon log in.
Optional("chroot_list"):
BoolVal(),
# the umask value for file creation. default is 022(18 in 10-based)
Optional("local_umask"):
IntVal(min=0, max=0777),
# matches all hosts in the domain cs.foo.edu. As these characters also
# match the dots in a domain name, the given pattern will also match all
# hosts within any subdomain of cs.foo.edu.
#
# IP networks
# You can also export directories to all hosts on an IP (sub-) network
# simultaneously. This is done by specifying an IP address and netmask
# pair as address/netmask where the netmask can be specified in dotted-
# decimal format, or as a contiguous mask length. For example, either
# 255.255.252.0 or 22 appended to the network base IPv4 address
# results in identical subnetworks with 10 bits of host. IPv6 addresses
# must use a contiguous mask length and must not be inside square brackets
# to avoid confusion with character-class wildcards. Wildcard characters
# generally do not work on IP addresses, though they may work by accident
# when reverse DNS lookups fail.
"host": StrRe("^(\S)*$"),
# The options to be used for host
Optional("options"): Default(StrRe("^(\S)*$"), default=""),
AutoDel(str): object # for all other key we auto delete
})
EXPORT_POINT_CONF_SCHEMA = Schema({
# export point name
"name": Use(str),
# absolute path
"path": Use(str),