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),