Use this API to add ntpserver.
356114
public static base_response add(nitro_service client, ntpserver resource) throws Exception {
		ntpserver addresource = new ntpserver();
		addresource.serverip = resource.serverip;
		addresource.servername = resource.servername;
		addresource.minpoll = resource.minpoll;
		addresource.maxpoll = resource.maxpoll;
		addresource.autokey = resource.autokey;
		addresource.key = resource.key;
		return addresource.add_resource(client);
	}
1359901
public static base_response add(nitro_service client, vpnvserver resource) throws Exception {
		vpnvserver addresource = new vpnvserver();
		addresource.name = resource.name;
		addresource.servicetype = resource.servicetype;
		addresource.ipv46 = resource.ipv46;
		addresource.range = resource.range;
		addresource.port = resource.port;
		addresource.state = resource.state;
		addresource.authentication = resource.authentication;
		addresource.doublehop = resource.doublehop;
		addresource.maxaaausers = resource.maxaaausers;
		addresource.icaonly = resource.icaonly;
		addresource.downstateflush = resource.downstateflush;
		addresource.listenpolicy = resource.listenpolicy;
		addresource.listenpriority = resource.listenpriority;
		addresource.tcpprofilename = resource.tcpprofilename;
		addresource.httpprofilename = resource.httpprofilename;
		addresource.comment = resource.comment;
		addresource.appflowlog = resource.appflowlog;
		addresource.icmpvsrresponse = resource.icmpvsrresponse;
		addresource.netprofile = resource.netprofile;
		addresource.cginfrahomepageredirect = resource.cginfrahomepageredirect;
		addresource.maxloginattempts = resource.maxloginattempts;
		addresource.failedlogintimeout = resource.failedlogintimeout;
		return addresource.add_resource(client);
	}
247403
public static base_responses add(nitro_service client, iptunnel resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			iptunnel addresources[] = new iptunnel[resources.length];
			for (int i=0;i<resources.length;i++){
				addresources[i] = new iptunnel();
				addresources[i].name = resources[i].name;
				addresources[i].remote = resources[i].remote;
				addresources[i].remotesubnetmask = resources[i].remotesubnetmask;
				addresources[i].local = resources[i].local;
				addresources[i].protocol = resources[i].protocol;
				addresources[i].ipsecprofilename = resources[i].ipsecprofilename;
			}
			result = add_bulk_request(client, addresources);
		}
		return result;
	}
939813
public static base_response add(nitro_service client, dnssrvrec resource) throws Exception {
		dnssrvrec addresource = new dnssrvrec();
		addresource.domain = resource.domain;
		addresource.target = resource.target;
		addresource.priority = resource.priority;
		addresource.weight = resource.weight;
		addresource.port = resource.port;
		addresource.ttl = resource.ttl;
		return addresource.add_resource(client);
	}
478669
public static ns_snmp_config add(nitro_service client, ns_snmp_config resource) throws Exception
	{
		resource.validate("add");
		return ((ns_snmp_config[]) resource.perform_operation(client, "add"))[0];
	}
1114581
public static base_responses update(nitro_service client, ntpserver resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			ntpserver updateresources[] = new ntpserver[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new ntpserver();
				updateresources[i].serverip = resources[i].serverip;
				updateresources[i].servername = resources[i].servername;
				updateresources[i].minpoll = resources[i].minpoll;
				updateresources[i].maxpoll = resources[i].maxpoll;
				updateresources[i].preferredntpserver = resources[i].preferredntpserver;
				updateresources[i].autokey = resources[i].autokey;
				updateresources[i].key = resources[i].key;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
662469
public static base_response add(nitro_service client, vpnnexthopserver resource) throws Exception {
		vpnnexthopserver addresource = new vpnnexthopserver();
		addresource.name = resource.name;
		addresource.nexthopip = resource.nexthopip;
		addresource.nexthopport = resource.nexthopport;
		addresource.secure = resource.secure;
		return addresource.add_resource(client);
	}
373893
public static base_response add(nitro_service client, dnsptrrec resource) throws Exception {
		dnsptrrec addresource = new dnsptrrec();
		addresource.reversedomain = resource.reversedomain;
		addresource.domain = resource.domain;
		addresource.ttl = resource.ttl;
		return addresource.add_resource(client);
	}
1263899
public static base_response add(nitro_service client, route resource) throws Exception {
		route addresource = new route();
		addresource.network = resource.network;
		addresource.netmask = resource.netmask;
		addresource.gateway = resource.gateway;
		addresource.cost = resource.cost;
		addresource.td = resource.td;
		addresource.distance = resource.distance;
		addresource.cost1 = resource.cost1;
		addresource.weight = resource.weight;
		addresource.advertise = resource.advertise;
		addresource.protocol = resource.protocol;
		addresource.msr = resource.msr;
		addresource.monitor = resource.monitor;
		return addresource.add_resource(client);
	}
487274
def vserver_add(v_name, v_ip, v_port, v_type, **connection_args):
    '''
    
    '''
    ret = True
    if vserver_exists(v_name, **connection_args):
        return False
    nitro = _connect(**connection_args)
    if nitro is None:
        return False
    vserver = NSLBVServer()
    vserver.set_name(v_name)
    vserver.set_ipv46(v_ip)
    vserver.set_port(v_port)
    vserver.set_servicetype(v_type.upper())
    try:
        NSLBVServer.add(nitro, vserver)
    except NSNitroError as error:
        log.debug('netscaler module error - NSLBVServer.add() failed: %s', error)
        ret = False
    _disconnect(nitro)
    return ret
1326280
public static base_response add(nitro_service client, nsip6 resource) throws Exception {
		nsip6 addresource = new nsip6();
		addresource.ipv6address = resource.ipv6address;
		addresource.scope = resource.scope;
		addresource.type = resource.type;
		addresource.vlan = resource.vlan;
		addresource.nd = resource.nd;
		addresource.icmp = resource.icmp;
		addresource.vserver = resource.vserver;
		addresource.telnet = resource.telnet;
		addresource.ftp = resource.ftp;
		addresource.gui = resource.gui;
		addresource.ssh = resource.ssh;
		addresource.snmp = resource.snmp;
		addresource.mgmtaccess = resource.mgmtaccess;
		addresource.restrictaccess = resource.restrictaccess;
		addresource.dynamicrouting = resource.dynamicrouting;
		addresource.hostroute = resource.hostroute;
		addresource.ip6hostrtgw = resource.ip6hostrtgw;
		addresource.metric = resource.metric;
		addresource.vserverrhilevel = resource.vserverrhilevel;
		addresource.ospf6lsatype = resource.ospf6lsatype;
		addresource.ospfarea = resource.ospfarea;
		addresource.state = resource.state;
		addresource.map = resource.map;
		addresource.ownernode = resource.ownernode;
		addresource.td = resource.td;
		return addresource.add_resource(client);
	}
1246763
def add_device_net(self, name, destname=None):
        

        if not self.running:
            return False

        if os.path.exists("/sys/class/net/%s/phy80211/name" % name):
            with open("/sys/class/net/%s/phy80211/name" % name) as fd:
                phy = fd.read().strip()

            if subprocess.call(['iw', 'phy', phy, 'set', 'netns',
                                str(self.init_pid)]) != 0:
                return False

            if destname:
                def rename_interface(args):
                    old, new = args

                    return subprocess.call(['ip', 'link', 'set',
                                            'dev', old, 'name', new])

                return self.attach_wait(rename_interface, (name, destname),
                                        namespaces=(CLONE_NEWNET)) == 0

            return True

        if not destname:
            destname = name

        if not os.path.exists("/sys/class/net/%s/" % name):
            return False

        return subprocess.call(['ip', 'link', 'set',
                                'dev', name,
                                'netns', str(self.init_pid),
                                'name', destname]) == 0
1013626
public static ntp_server add(nitro_service client, ntp_server resource) throws Exception
	{
		resource.validate("add");
		return ((ntp_server[]) resource.perform_operation(client, "add"))[0];
	}
661562
def add(env, securitygroup_id, network_component, server, interface):
    """"""
    _validate_args(network_component, server, interface)

    mgr = SoftLayer.NetworkManager(env.client)
    component_id = _get_component_id(env, network_component, server, interface)

    ret = mgr.attach_securitygroup_component(securitygroup_id,
                                             component_id)
    if not ret:
        raise exceptions.CLIAbort("Could not attach network component")

    table = formatting.Table(REQUEST_COLUMNS)
    table.add_row([ret['requestId']])

    env.fout(table)
1277296
public static base_response add(nitro_service client, dnssuffix resource) throws Exception {
		dnssuffix addresource = new dnssuffix();
		addresource.Dnssuffix = resource.Dnssuffix;
		return addresource.add_resource(client);
	}
838474
public static base_response add(nitro_service client, forwardingsession resource) throws Exception {
		forwardingsession addresource = new forwardingsession();
		addresource.name = resource.name;
		addresource.network = resource.network;
		addresource.netmask = resource.netmask;
		addresource.acl6name = resource.acl6name;
		addresource.aclname = resource.aclname;
		addresource.connfailover = resource.connfailover;
		return addresource.add_resource(client);
	}
229931
public static ntpserver[] get(nitro_service service) throws Exception{
		ntpserver obj = new ntpserver();
		ntpserver[] response = (ntpserver[])obj.get_resources(service);
		return response;
	}