Validate the given response against the API operation.

@param exchange The exchange to validate
@param swaggerOperation The API operation to validate the response against

@return A status containing validation error
354886
public Status validateResponse(final HttpServerExchange exchange, final SwaggerOperation swaggerOperation) {
        requireNonNull(exchange, "An exchange is required");
        requireNonNull(swaggerOperation, "A swagger operation is required");

        io.swagger.models.Response swaggerResponse = swaggerOperation.getOperation().getResponses().get(Integer.toString(exchange.getStatusCode()));
        if (swaggerResponse == null) {
            swaggerResponse = swaggerOperation.getOperation().getResponses().get("default"); // try the default response
        }

        if (swaggerResponse == null) {
            return new Status("ERR11015", exchange.getStatusCode(), swaggerOperation.getPathString().original());
        }

        if (swaggerResponse.getSchema() == null) {
            return null;
        }
        String body = exchange.getOutputStream().toString();

        if (body == null || body.length() == 0) {
            return new Status("ERR11016", swaggerOperation.getMethod(), swaggerOperation.getPathString().original());
        }
        return schemaValidator.validate(body, swaggerResponse.getSchema());
    }
337776
protected void validate(String operationType) throws Exception
	{
		super.validate(operationType);

		MPSString bandwidth_validator = new MPSString();
		bandwidth_validator.setConstraintIsReq(MPSConstants.GENERIC_CONSTRAINT, true);
		bandwidth_validator.validate(operationType, bandwidth, "\"bandwidth\"");
		
		MPSString boostmode_validator = new MPSString();
		boostmode_validator.setConstraintIsReq(MPSConstants.GENERIC_CONSTRAINT, true);
		boostmode_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 128);
		boostmode_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		boostmode_validator.validate(operationType, boostmode, "\"boostmode\"");
		
		MPSInt min_rate_validator = new MPSInt();
		min_rate_validator.setConstraintIsReq(MPSConstants.GENERIC_CONSTRAINT, true);
		min_rate_validator.validate(operationType, min_rate, "\"min_rate\"");
		
		MPSInt send_limit_validator = new MPSInt();
		send_limit_validator.setConstraintIsReq(MPSConstants.GENERIC_CONSTRAINT, true);
		send_limit_validator.validate(operationType, send_limit, "\"send_limit\"");
		
		MPSInt receive_limit_validator = new MPSInt();
		receive_limit_validator.setConstraintIsReq(MPSConstants.GENERIC_CONSTRAINT, true);
		receive_limit_validator.validate(operationType, receive_limit, "\"receive_limit\"");
		
		MPSIPAddress br_ip_address_arr_validator = new MPSIPAddress();
		br_ip_address_arr_validator.setConstraintIsReq(MPSConstants.GENERIC_CONSTRAINT, true);
		if(br_ip_address_arr != null)
		{
			for(int i=0; i<br_ip_address_arr.length; i++)
			{
				br_ip_address_arr_validator.validate(operationType, br_ip_address_arr[i], "br_ip_address_arr["+i+"]");
			}
		}
		
	}
806610
protected Assertion validateServiceTicket(final WebApplicationService service, final String serviceTicketId) {
        return serviceValidateConfigurationContext.getCentralAuthenticationService().validateServiceTicket(serviceTicketId, service);
    }
329230
protected void validate(String operationType) throws Exception
	{
		super.validate(operationType);

		MPSString withdefaults_validator = new MPSString();
		withdefaults_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		withdefaults_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		withdefaults_validator.validate(operationType, withdefaults, "\"withdefaults\"");
		
		MPSString response_validator = new MPSString();
		response_validator.validate(operationType, response, "\"response\"");
		
		MPSIPAddress ns_ip_address_validator = new MPSIPAddress();
		ns_ip_address_validator.validate(operationType, ns_ip_address, "\"ns_ip_address\"");
		
	}
1275028
protected void validate(String operationType) throws Exception
	{
		super.validate(operationType);

		MPSString boostmode_validator = new MPSString();
		boostmode_validator.setConstraintIsReq(MPSConstants.GENERIC_CONSTRAINT, true);
		boostmode_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 128);
		boostmode_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		boostmode_validator.validate(operationType, boostmode, "\"boostmode\"");
		
		MPSInt receive_limit_validator = new MPSInt();
		receive_limit_validator.setConstraintIsReq(MPSConstants.GENERIC_CONSTRAINT, true);
		receive_limit_validator.validate(operationType, receive_limit, "\"receive_limit\"");
		
		MPSIPAddress br_ip_address_arr_validator = new MPSIPAddress();
		br_ip_address_arr_validator.setConstraintIsReq(MPSConstants.GENERIC_CONSTRAINT, true);
		if(br_ip_address_arr != null)
		{
			for(int i=0; i<br_ip_address_arr.length; i++)
			{
				br_ip_address_arr_validator.validate(operationType, br_ip_address_arr[i], "br_ip_address_arr["+i+"]");
			}
		}
		
	}
421800
protected void validate(String operationType) throws Exception
	{
		super.validate(operationType);

		MPSString name_validator = new MPSString();
		name_validator.setConstraintIsReq(MPSConstants.DELETE_CONSTRAINT, true);
		name_validator.setConstraintCharSetRegEx(MPSConstants.GENERIC_CONSTRAINT,"[ a-zA-Z0-9_#.:@=-]+");
		name_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		name_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		name_validator.setConstraintIsReq(MPSConstants.ADD_CONSTRAINT, true);
		name_validator.setConstraintIsReq(MPSConstants.MODIFY_CONSTRAINT, true);
		name_validator.validate(operationType, name, "\"name\"");
		
		MPSInt security_level_validator = new MPSInt();
		security_level_validator.setConstraintMinValue(MPSConstants.GENERIC_CONSTRAINT, 0);
		security_level_validator.setConstraintMaxValue(MPSConstants.GENERIC_CONSTRAINT, 2);
		security_level_validator.setConstraintIsReq(MPSConstants.ADD_CONSTRAINT, true);
		security_level_validator.setConstraintIsReq(MPSConstants.MODIFY_CONSTRAINT, true);
		security_level_validator.validate(operationType, security_level, "\"security_level\"");
		
		MPSInt auth_protocol_validator = new MPSInt();
		auth_protocol_validator.setConstraintMinValue(MPSConstants.GENERIC_CONSTRAINT, 0);
		auth_protocol_validator.setConstraintMaxValue(MPSConstants.GENERIC_CONSTRAINT, 2);
		auth_protocol_validator.validate(operationType, auth_protocol, "\"auth_protocol\"");
		
		MPSString auth_password_validator = new MPSString();
		auth_password_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		auth_password_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 8);
		auth_password_validator.validate(operationType, auth_password, "\"auth_password\"");
		
		MPSInt privacy_protocol_validator = new MPSInt();
		privacy_protocol_validator.setConstraintMinValue(MPSConstants.GENERIC_CONSTRAINT, 0);
		privacy_protocol_validator.setConstraintMaxValue(MPSConstants.GENERIC_CONSTRAINT, 2);
		privacy_protocol_validator.validate(operationType, privacy_protocol, "\"privacy_protocol\"");
		
		MPSString privacy_password_validator = new MPSString();
		privacy_password_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		privacy_password_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 8);
		privacy_password_validator.validate(operationType, privacy_password, "\"privacy_password\"");
		
		MPSString view_name_validator = new MPSString();
		view_name_validator.setConstraintCharSetRegEx(MPSConstants.GENERIC_CONSTRAINT,"[ a-zA-Z0-9_#.:@=-]+");
		view_name_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		view_name_validator.validate(operationType, view_name, "\"view_name\"");
		
		MPSString security_level_str_validator = new MPSString();
		security_level_str_validator.validate(operationType, security_level_str, "\"security_level_str\"");
		
		MPSString auth_protocol_str_validator = new MPSString();
		auth_protocol_str_validator.validate(operationType, auth_protocol_str, "\"auth_protocol_str\"");
		
		MPSString privacy_protocol_str_validator = new MPSString();
		privacy_protocol_str_validator.validate(operationType, privacy_protocol_str, "\"privacy_protocol_str\"");
		
	}
24281
protected void validate(String operationType) throws Exception
	{
		super.validate(operationType);

		MPSString name_validator = new MPSString();
		name_validator.setConstraintIsReq(MPSConstants.DELETE_CONSTRAINT, true);
		name_validator.setConstraintCharSetRegEx(MPSConstants.GENERIC_CONSTRAINT,"[ a-zA-Z0-9_#.:@=-]+");
		name_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		name_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		name_validator.setConstraintIsReq(MPSConstants.ADD_CONSTRAINT, true);
		name_validator.setConstraintIsReq(MPSConstants.MODIFY_CONSTRAINT, true);
		name_validator.validate(operationType, name, "\"name\"");
		
		MPSString subtree_validator = new MPSString();
		subtree_validator.setConstraintCharSetRegEx(MPSConstants.GENERIC_CONSTRAINT,"[ a-zA-Z0-9_#.:@=-]+");
		subtree_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 256);
		subtree_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		subtree_validator.validate(operationType, subtree, "\"subtree\"");
		
		MPSBoolean type_validator = new MPSBoolean();
		type_validator.validate(operationType, type, "\"type\"");
		
		MPSString type_str_validator = new MPSString();
		type_str_validator.validate(operationType, type_str, "\"type_str\"");
		
	}
922155
protected void validate(String operationType) throws Exception
	{
		super.validate(operationType);

		MPSInternetHost server_validator = new MPSInternetHost();
		server_validator.setConstraintIsReq(MPSConstants.ADD_CONSTRAINT, true);
		server_validator.validate(operationType, server, "\"server\"");
		
		MPSInt minpoll_validator = new MPSInt();
		minpoll_validator.setConstraintMinValue(MPSConstants.GENERIC_CONSTRAINT, 0);
		minpoll_validator.setConstraintMaxValue(MPSConstants.GENERIC_CONSTRAINT, 6);
		minpoll_validator.validate(operationType, minpoll, "\"minpoll\"");
		
		MPSInt maxpoll_validator = new MPSInt();
		maxpoll_validator.setConstraintMinValue(MPSConstants.GENERIC_CONSTRAINT, 0);
		maxpoll_validator.setConstraintMaxValue(MPSConstants.GENERIC_CONSTRAINT, 17);
		maxpoll_validator.validate(operationType, maxpoll, "\"maxpoll\"");
		
		MPSInt key_id_validator = new MPSInt();
		key_id_validator.setConstraintMinValue(MPSConstants.GENERIC_CONSTRAINT, 0);
		key_id_validator.setConstraintMaxValue(MPSConstants.GENERIC_CONSTRAINT, 65534);
		key_id_validator.validate(operationType, key_id, "\"key_id\"");
		
		MPSBoolean autokey_validator = new MPSBoolean();
		autokey_validator.validate(operationType, autokey, "\"autokey\"");
		
		MPSBoolean preferred_server_validator = new MPSBoolean();
		preferred_server_validator.validate(operationType, preferred_server, "\"preferred_server\"");
		
	}
499959
protected void validate(String operationType) throws Exception
	{
		super.validate(operationType);

		MPSIPAddress ipaddress_validator = new MPSIPAddress();
		ipaddress_validator.validate(operationType, ipaddress, "\"ipaddress\"");
		
		MPSIPAddress clip_validator = new MPSIPAddress();
		clip_validator.validate(operationType, clip, "\"clip\"");
		
		MPSInt nodeid_validator = new MPSInt();
		nodeid_validator.setConstraintMinValue(MPSConstants.GENERIC_CONSTRAINT, 0);
		nodeid_validator.setConstraintMaxValue(MPSConstants.GENERIC_CONSTRAINT, 31);
		nodeid_validator.validate(operationType, nodeid, "\"nodeid\"");
		
		MPSInt clusterid_validator = new MPSInt();
		clusterid_validator.setConstraintMinValue(MPSConstants.GENERIC_CONSTRAINT, 1);
		clusterid_validator.setConstraintMaxValue(MPSConstants.GENERIC_CONSTRAINT, 16);
		clusterid_validator.validate(operationType, clusterid, "\"clusterid\"");
		
		MPSString password_validator = new MPSString();
		password_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 128);
		password_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		password_validator.validate(operationType, password, "\"password\"");
		
		MPSBoolean iscco_validator = new MPSBoolean();
		iscco_validator.validate(operationType, iscco, "\"iscco\"");
		
		MPSString backplane_validator = new MPSString();
		backplane_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		backplane_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		backplane_validator.validate(operationType, backplane, "\"backplane\"");
		
		MPSString health_validator = new MPSString();
		health_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		health_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		health_validator.validate(operationType, health, "\"health\"");
		
		MPSString state_validator = new MPSString();
		state_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		state_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		state_validator.validate(operationType, state, "\"state\"");
		
		MPSIPAddress clviewleader_validator = new MPSIPAddress();
		clviewleader_validator.validate(operationType, clviewleader, "\"clviewleader\"");
		
		MPSDouble clbkplanerx_validator = new MPSDouble();
		clbkplanerx_validator.validate(operationType, clbkplanerx, "\"clbkplanerx\"");
		
		MPSDouble clbkplanetx_validator = new MPSDouble();
		clbkplanetx_validator.validate(operationType, clbkplanetx, "\"clbkplanetx\"");
		
		MPSDouble clbkplanerxrate_validator = new MPSDouble();
		clbkplanerxrate_validator.validate(operationType, clbkplanerxrate, "\"clbkplanerxrate\"");
		
		MPSDouble clbkplanetxrate_validator = new MPSDouble();
		clbkplanetxrate_validator.validate(operationType, clbkplanetxrate, "\"clbkplanetxrate\"");
		
		MPSDouble totsteeredpkts_validator = new MPSDouble();
		totsteeredpkts_validator.validate(operationType, totsteeredpkts, "\"totsteeredpkts\"");
		
		MPSDouble numdfddroppkts_validator = new MPSDouble();
		numdfddroppkts_validator.validate(operationType, numdfddroppkts, "\"numdfddroppkts\"");
		
		MPSDouble totpropagationtimeout_validator = new MPSDouble();
		totpropagationtimeout_validator.validate(operationType, totpropagationtimeout, "\"totpropagationtimeout\"");
		
		MPSString clcurstatus_validator = new MPSString();
		clcurstatus_validator.validate(operationType, clcurstatus, "\"clcurstatus\"");
		
		MPSInt clnumnodes_validator = new MPSInt();
		clnumnodes_validator.setConstraintMinValue(MPSConstants.GENERIC_CONSTRAINT, 0);
		clnumnodes_validator.setConstraintMaxValue(MPSConstants.GENERIC_CONSTRAINT, 32);
		clnumnodes_validator.validate(operationType, clnumnodes, "\"clnumnodes\"");
		
		MPSDouble cpu_usage_validator = new MPSDouble();
		cpu_usage_validator.validate(operationType, cpu_usage, "\"cpu_usage\"");
		
		MPSDouble mgmt_cpu_usage_validator = new MPSDouble();
		mgmt_cpu_usage_validator.validate(operationType, mgmt_cpu_usage, "\"mgmt_cpu_usage\"");
		
		MPSDouble memory_usage_validator = new MPSDouble();
		memory_usage_validator.validate(operationType, memory_usage, "\"memory_usage\"");
		
		MPSDouble tx_validator = new MPSDouble();
		tx_validator.validate(operationType, tx, "\"tx\"");
		
		MPSDouble rx_validator = new MPSDouble();
		rx_validator.validate(operationType, rx, "\"rx\"");
		
		MPSDouble http_req_validator = new MPSDouble();
		http_req_validator.validate(operationType, http_req, "\"http_req\"");
		
		MPSString profile_name_validator = new MPSString();
		profile_name_validator.setConstraintCharSetRegEx(MPSConstants.GENERIC_CONSTRAINT,"[ a-zA-Z0-9_#.:@=-]+");
		profile_name_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 128);
		profile_name_validator.validate(operationType, profile_name, "\"profile_name\"");
		
		MPSString clnodes_validator = new MPSString();
		clnodes_validator.validate(operationType, clnodes, "\"clnodes\"");
		
		MPSString act_id_validator = new MPSString();
		act_id_validator.validate(operationType, act_id, "\"act_id\"");
		
		MPSString operationalstate_validator = new MPSString();
		operationalstate_validator.validate(operationType, operationalstate, "\"operationalstate\"");
		
	}
549651
private boolean validateAssertion(final HttpServletRequest request, final String serviceTicketId, final Assertion assertion, final Service service) {
        for (val spec : serviceValidateConfigurationContext.getValidationSpecifications()) {
            spec.reset();
            val binder = new ServletRequestDataBinder(spec, "validationSpecification");
            initBinder(request, binder);
            binder.bind(request);
            if (!spec.isSatisfiedBy(assertion, request)) {
                LOGGER.warn("Service ticket [{}] does not satisfy validation specification.", serviceTicketId);
                return false;
            }
        }
        enforceTicketValidationAuthorizationFor(request, service, assertion);
        return true;
    }
1271445
protected void validate(String operationType) throws Exception
	{
		super.validate(operationType);

		MPSString id_validator = new MPSString();
		id_validator.setConstraintIsReq(MPSConstants.DELETE_CONSTRAINT, true);
		id_validator.setConstraintIsReq(MPSConstants.MODIFY_CONSTRAINT, true);
		id_validator.validate(operationType, id, "\"id\"");
		
		MPSIPAddress ip_address_validator = new MPSIPAddress();
		ip_address_validator.setConstraintIsReq(MPSConstants.ADD_CONSTRAINT, true);
		ip_address_validator.validate(operationType, ip_address, "\"ip_address\"");
		
		MPSString type_validator = new MPSString();
		type_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 64);
		type_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		type_validator.validate(operationType, type, "\"type\"");
		
		MPSString profile_name_validator = new MPSString();
		profile_name_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 128);
		profile_name_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		profile_name_validator.validate(operationType, profile_name, "\"profile_name\"");
		
		MPSBoolean user_driven_validator = new MPSBoolean();
		user_driven_validator.validate(operationType, user_driven, "\"user_driven\"");
		
		MPSInt ping_state_validator = new MPSInt();
		ping_state_validator.validate(operationType, ping_state, "\"ping_state\"");
		
		MPSString status_validator = new MPSString();
		status_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 64);
		status_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		status_validator.validate(operationType, status, "\"status\"");
		
		MPSString reason_validator = new MPSString();
		reason_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 1024);
		reason_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		reason_validator.validate(operationType, reason, "\"reason\"");
		
		MPSString name_validator = new MPSString();
		name_validator.setConstraintCharSetRegEx(MPSConstants.GENERIC_CONSTRAINT,"[a-zA-Z0-9_#.:@=-]+");
		name_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 128);
		name_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		name_validator.validate(operationType, name, "\"name\"");
		
		MPSIPAddress netmask_validator = new MPSIPAddress();
		netmask_validator.validate(operationType, netmask, "\"netmask\"");
		
		MPSIPAddress gateway_validator = new MPSIPAddress();
		gateway_validator.validate(operationType, gateway, "\"gateway\"");
		
		MPSString hostname_validator = new MPSString();
		hostname_validator.setConstraintCharSetRegEx(MPSConstants.GENERIC_CONSTRAINT,"[ a-zA-Z0-9_#.:@=-]+");
		hostname_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 256);
		hostname_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		hostname_validator.validate(operationType, hostname, "\"hostname\"");
		
		MPSString description_validator = new MPSString();
		description_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 512);
		description_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		description_validator.validate(operationType, description, "\"description\"");
		
		MPSString device_family_validator = new MPSString();
		device_family_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 64);
		device_family_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		device_family_validator.validate(operationType, device_family, "\"device_family\"");
		
		MPSString version_validator = new MPSString();
		version_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 256);
		version_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		version_validator.validate(operationType, version, "\"version\"");
		
		MPSString instance_state_validator = new MPSString();
		instance_state_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 64);
		instance_state_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		instance_state_validator.validate(operationType, instance_state, "\"instance_state\"");
		
		MPSString profile_username_validator = new MPSString();
		profile_username_validator.setConstraintCharSetRegEx(MPSConstants.GENERIC_CONSTRAINT,"[ a-zA-Z0-9_#.:@=-]+");
		profile_username_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 128);
		profile_username_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		profile_username_validator.validate(operationType, profile_username, "\"profile_username\"");
		
		MPSString profile_password_validator = new MPSString();
		profile_password_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 128);
		profile_password_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		profile_password_validator.validate(operationType, profile_password, "\"profile_password\"");
		
		MPSString act_id_validator = new MPSString();
		act_id_validator.validate(operationType, act_id, "\"act_id\"");
		
	}
1147969
protected void validate(String operationType) throws Exception
	{
		super.validate(operationType);

		MPSString response_validator = new MPSString();
		response_validator.validate(operationType, response, "\"response\"");
		
	}
1130291
protected void validate(String operationType) throws Exception
	{
		super.validate(operationType);

		MPSString id_validator = new MPSString();
		id_validator.setConstraintIsReq(MPSConstants.ADD_CONSTRAINT, true);
		id_validator.setConstraintIsReq(MPSConstants.MODIFY_CONSTRAINT, true);
		id_validator.validate(operationType, id, "\"id\"");
		
		MPSString task_device_id_validator = new MPSString();
		task_device_id_validator.validate(operationType, task_device_id, "\"task_device_id\"");
		
		MPSString command_validator = new MPSString();
		command_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 1024);
		command_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		command_validator.validate(operationType, command, "\"command\"");
		
		MPSString protocol_validator = new MPSString();
		protocol_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		protocol_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		protocol_validator.validate(operationType, protocol, "\"protocol\"");
		
		MPSInt starttime_validator = new MPSInt();
		starttime_validator.validate(operationType, starttime, "\"starttime\"");
		
		MPSInt endtime_validator = new MPSInt();
		endtime_validator.validate(operationType, endtime, "\"endtime\"");
		
		MPSString status_validator = new MPSString();
		status_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 128);
		status_validator.validate(operationType, status, "\"status\"");
		
		MPSString statusmessage_validator = new MPSString();
		statusmessage_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 4096);
		statusmessage_validator.validate(operationType, statusmessage, "\"statusmessage\"");
		
	}
58120
protected void validate(String operationType) throws Exception
	{
		super.validate(operationType);

		MPSDouble br_cpu_usage_validator = new MPSDouble();
		br_cpu_usage_validator.validate(operationType, br_cpu_usage, "\"br_cpu_usage\"");
		
		MPSDouble br_memory_usage_validator = new MPSDouble();
		br_memory_usage_validator.validate(operationType, br_memory_usage, "\"br_memory_usage\"");
		
		MPSDouble wan_out_validator = new MPSDouble();
		wan_out_validator.validate(operationType, wan_out, "\"wan_out\"");
		
		MPSDouble lan_out_validator = new MPSDouble();
		lan_out_validator.validate(operationType, lan_out, "\"lan_out\"");
		
		MPSString upsince_validator = new MPSString();
		upsince_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 128);
		upsince_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		upsince_validator.validate(operationType, upsince, "\"upsince\"");
		
		MPSString ha_peer_state_validator = new MPSString();
		ha_peer_state_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		ha_peer_state_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		ha_peer_state_validator.validate(operationType, ha_peer_state, "\"ha_peer_state\"");
		
		MPSString ha_state_validator = new MPSString();
		ha_state_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		ha_state_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		ha_state_validator.validate(operationType, ha_state, "\"ha_state\"");
		
		MPSIPAddress ha_peer_ip_address_validator = new MPSIPAddress();
		ha_peer_ip_address_validator.validate(operationType, ha_peer_ip_address, "\"ha_peer_ip_address\"");
		
		MPSDouble ha_peer_id_validator = new MPSDouble();
		ha_peer_id_validator.validate(operationType, ha_peer_id, "\"ha_peer_id\"");
		
		MPSString operation_status_validator = new MPSString();
		operation_status_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 128);
		operation_status_validator.validate(operationType, operation_status, "\"operation_status\"");
		
		MPSString bypass_validator = new MPSString();
		bypass_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 128);
		bypass_validator.validate(operationType, bypass, "\"bypass\"");
		
		MPSString bandwidth_mode_validator = new MPSString();
		bandwidth_mode_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 128);
		bandwidth_mode_validator.validate(operationType, bandwidth_mode, "\"bandwidth_mode\"");
		
		MPSDoubleLong bandwidth_limit_validator = new MPSDoubleLong();
		bandwidth_limit_validator.validate(operationType, bandwidth_limit, "\"bandwidth_limit\"");
		
		MPSIPAddress havmip_validator = new MPSIPAddress();
		havmip_validator.validate(operationType, havmip, "\"havmip\"");
		
		MPSString acl_connections_validator = new MPSString();
		acl_connections_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		acl_connections_validator.validate(operationType, acl_connections, "\"acl_connections\"");
		
		MPSString unacl_connections_validator = new MPSString();
		unacl_connections_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		unacl_connections_validator.validate(operationType, unacl_connections, "\"unacl_connections\"");
		
		MPSString connected_plugins_validator = new MPSString();
		connected_plugins_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		connected_plugins_validator.validate(operationType, connected_plugins, "\"connected_plugins\"");
		
		MPSString max_plugins_validator = new MPSString();
		max_plugins_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 32);
		max_plugins_validator.validate(operationType, max_plugins, "\"max_plugins\"");
		
		MPSDouble wan_in_validator = new MPSDouble();
		wan_in_validator.validate(operationType, wan_in, "\"wan_in\"");
		
		MPSDouble lan_in_validator = new MPSDouble();
		lan_in_validator.validate(operationType, lan_in, "\"lan_in\"");
		
		MPSDouble wan_out_prev_validator = new MPSDouble();
		wan_out_prev_validator.validate(operationType, wan_out_prev, "\"wan_out_prev\"");
		
		MPSDouble lan_out_prev_validator = new MPSDouble();
		lan_out_prev_validator.validate(operationType, lan_out_prev, "\"lan_out_prev\"");
		
		MPSDouble wan_in_prev_validator = new MPSDouble();
		wan_in_prev_validator.validate(operationType, wan_in_prev, "\"wan_in_prev\"");
		
		MPSDouble lan_in_prev_validator = new MPSDouble();
		lan_in_prev_validator.validate(operationType, lan_in_prev, "\"lan_in_prev\"");
		
		MPSDouble prev_poll_time_validator = new MPSDouble();
		prev_poll_time_validator.validate(operationType, prev_poll_time, "\"prev_poll_time\"");
		
		MPSIPAddress apa_ip_address_validator = new MPSIPAddress();
		apa_ip_address_validator.setConstraintIsReq(MPSConstants.ADD_CONSTRAINT, true);
		apa_ip_address_validator.validate(operationType, apa_ip_address, "\"apa_ip_address\"");
		
		MPSIPAddress apa_netmask_validator = new MPSIPAddress();
		apa_netmask_validator.setConstraintIsReq(MPSConstants.ADD_CONSTRAINT, true);
		apa_netmask_validator.validate(operationType, apa_netmask, "\"apa_netmask\"");
		
		MPSIPAddress apa_gateway_validator = new MPSIPAddress();
		apa_gateway_validator.setConstraintIsReq(MPSConstants.ADD_CONSTRAINT, true);
		apa_gateway_validator.validate(operationType, apa_gateway, "\"apa_gateway\"");
		
		MPSIPAddress plugin_ip_address_validator = new MPSIPAddress();
		plugin_ip_address_validator.setConstraintIsReq(MPSConstants.ADD_CONSTRAINT, true);
		plugin_ip_address_validator.validate(operationType, plugin_ip_address, "\"plugin_ip_address\"");
		
		MPSDouble system_load_validator = new MPSDouble();
		system_load_validator.validate(operationType, system_load, "\"system_load\"");
		
		MPSDouble active_connections_validator = new MPSDouble();
		active_connections_validator.validate(operationType, active_connections, "\"active_connections\"");
		
		MPSIPAddress mgmt_ip_address_validator = new MPSIPAddress();
		mgmt_ip_address_validator.validate(operationType, mgmt_ip_address, "\"mgmt_ip_address\"");
		
		MPSString license_validator = new MPSString();
		license_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 64);
		license_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		license_validator.validate(operationType, license, "\"license\"");
		
	}
510426
protected void validate(String operationType) throws Exception
	{
		super.validate(operationType);

		MPSIPAddress source_ip_address_validator = new MPSIPAddress();
		source_ip_address_validator.validate(operationType, source_ip_address, "\"source_ip_address\"");
		
		MPSIPAddress target_ip_address_arr_validator = new MPSIPAddress();
		if(target_ip_address_arr != null)
		{
			for(int i=0; i<target_ip_address_arr.length; i++)
			{
				target_ip_address_arr_validator.validate(operationType, target_ip_address_arr[i], "target_ip_address_arr["+i+"]");
			}
		}
		
	}
645643
protected void validate(String operationType) throws Exception
	{
		super.validate(operationType);

		MPSIPAddress xen_ip_address_validator = new MPSIPAddress();
		xen_ip_address_validator.setConstraintIsReq(MPSConstants.MODIFY_CONSTRAINT, true);
		xen_ip_address_validator.validate(operationType, xen_ip_address, "\"xen_ip_address\"");
		
		MPSIPAddress netmask_validator = new MPSIPAddress();
		netmask_validator.setConstraintIsReq(MPSConstants.MODIFY_CONSTRAINT, true);
		netmask_validator.validate(operationType, netmask, "\"netmask\"");
		
		MPSIPAddress gateway_validator = new MPSIPAddress();
		gateway_validator.setConstraintIsReq(MPSConstants.MODIFY_CONSTRAINT, true);
		gateway_validator.validate(operationType, gateway, "\"gateway\"");
		
		MPSIPAddress svm_ip_address_validator = new MPSIPAddress();
		svm_ip_address_validator.setConstraintIsReq(MPSConstants.MODIFY_CONSTRAINT, true);
		svm_ip_address_validator.validate(operationType, svm_ip_address, "\"svm_ip_address\"");
		
		MPSIPAddress dns_validator = new MPSIPAddress();
		dns_validator.validate(operationType, dns, "\"dns\"");
		
		MPSString network_interface_validator = new MPSString();
		network_interface_validator.setConstraintMaxStrLen(MPSConstants.GENERIC_CONSTRAINT, 15);
		network_interface_validator.setConstraintMinStrLen(MPSConstants.GENERIC_CONSTRAINT, 1);
		network_interface_validator.setConstraintIsReq(MPSConstants.MODIFY_CONSTRAINT, true);
		network_interface_validator.validate(operationType, network_interface, "\"network_interface\"");
		
	}
253021
protected void validate(String operationType) throws Exception
	{
		super.validate(operationType);

		MPSString id_validator = new MPSString();
		id_validator.validate(operationType, id, "\"id\"");
		
		MPSIPAddress ip_address_validator = new MPSIPAddress();
		ip_address_validator.validate(operationType, ip_address, "\"ip_address\"");
		
		MPSString app_name_validator = new MPSString();
		app_name_validator.validate(operationType, app_name, "\"app_name\"");
		
		MPSDouble total_wan_volume_validator = new MPSDouble();
		total_wan_volume_validator.validate(operationType, total_wan_volume, "\"total_wan_volume\"");
		
		MPSDouble total_sent_wan_volume_validator = new MPSDouble();
		total_sent_wan_volume_validator.validate(operationType, total_sent_wan_volume, "\"total_sent_wan_volume\"");
		
		MPSDouble total_received_wan_volume_validator = new MPSDouble();
		total_received_wan_volume_validator.validate(operationType, total_received_wan_volume, "\"total_received_wan_volume\"");
		
	}