Use this API to enable nsip.
191473
public static base_response enable(nitro_service client, nsip resource) throws Exception {
		nsip enableresource = new nsip();
		enableresource.ipaddress = resource.ipaddress;
		enableresource.td = resource.td;
		return enableresource.perform_operation(client,"enable");
	}
1305298
public void enable() {

        updateState("up");
        m_enabled = true;
        // show the current file input field
        if (m_fileInput != null) {
            m_fileInput.getElement().getStyle().clearDisplay();
        }
        super.setTitle(m_title);
    }
802930
@Override
	public void addSipConnector(String ipAddress, int port, String transport) throws LifecycleException
	{
		SipConnector sipConnector = mssContainer.createSipConnector(ipAddress, port, transport);
		mssContainer.addSipConnector(sipConnector);
	}
1087532
public static base_responses enable(nitro_service client, String acl6name[]) throws Exception {
		base_responses result = null;
		if (acl6name != null && acl6name.length > 0) {
			nsacl6 enableresources[] = new nsacl6[acl6name.length];
			for (int i=0;i<acl6name.length;i++){
				enableresources[i] = new nsacl6();
				enableresources[i].acl6name = acl6name[i];
			}
			result = perform_operation_bulk_request(client, enableresources,"enable");
		}
		return result;
	}
378453
def activateAaPdpContextRequest(AccessPointName_presence=0,
                                ProtocolConfigurationOptions_presence=0,
                                GprsTimer_presence=0):
    """"""
    a = TpPd(pd=0x8)
    b = MessageType(mesType=0x50)  # 01010000
    c = NetworkServiceAccessPointIdentifier()
    d = LlcServiceAccessPointIdentifier()
    e = QualityOfService()
    f = PacketDataProtocolAddress()
    packet = a / b / c / d / e / f
    if AccessPointName_presence is 1:
        g = AccessPointName(ieiAPN=0x28)
        packet = packet / g
    if ProtocolConfigurationOptions_presence is 1:
        h = ProtocolConfigurationOptions(ieiPCO=0x27)
        packet = packet / h
    if GprsTimer_presence is 1:
        i = GprsTimer(ieiGT=0x29)
        packet = packet / i
    return packet
59316
def __enableProxy(self):
        
        os.environ[
            "HTTP_PROXY"] = self.httpProxy()
        os.environ[
            "HTTPS_PROXY"] = self.httpsProxy()

        os.environ["REQUESTS_CA_BUNDLE"] = os.path.join(
            os.path.dirname(
                os.path.abspath(__file__)),
            "cert.pem")
176716
@SuppressWarnings({ "rawtypes", "unchecked" })
    public static synchronized void enable() {
        if (enabled) {
            return;
        }

        oldOnObservableAssembly = RxJavaPlugins.getOnObservableAssembly();
        RxJavaPlugins.setOnObservableAssembly(compose(
                oldOnObservableAssembly,
                new ConditionalOnCurrentRequestContextFunction<Observable>() {
                    @Override
                    Observable applyActual(Observable o, RequestContext ctx) {
                        if (!(o instanceof Callable)) {
                            return new RequestContextObservable(o, ctx);
                        }
                        if (o instanceof ScalarCallable) {
                            return new RequestContextScalarCallableObservable(o, ctx);
                        }
                        return new RequestContextCallableObservable(o, ctx);
                    }
                }));

        oldOnConnectableObservableAssembly = RxJavaPlugins.getOnConnectableObservableAssembly();
        RxJavaPlugins.setOnConnectableObservableAssembly(compose(
                oldOnConnectableObservableAssembly,
                new ConditionalOnCurrentRequestContextFunction<ConnectableObservable>() {
                    @Override
                    ConnectableObservable applyActual(ConnectableObservable co, RequestContext ctx) {
                        return new RequestContextConnectableObservable(co, ctx);
                    }
                }));

        oldOnCompletableAssembly = RxJavaPlugins.getOnCompletableAssembly();
        RxJavaPlugins.setOnCompletableAssembly(
                compose(oldOnCompletableAssembly,
                        new ConditionalOnCurrentRequestContextFunction<Completable>() {
                            @Override
                            Completable applyActual(Completable c,
                                                    RequestContext ctx) {
                                if (!(c instanceof Callable)) {
                                    return new RequestContextCompletable(c, ctx);
                                }
                                if (c instanceof ScalarCallable) {
                                    return new RequestContextScalarCallableCompletable(
                                            c, ctx);
                                }
                                return new RequestContextCallableCompletable(c, ctx);
                            }
                        }));

        oldOnSingleAssembly = RxJavaPlugins.getOnSingleAssembly();
        RxJavaPlugins.setOnSingleAssembly(
                compose(oldOnSingleAssembly, new ConditionalOnCurrentRequestContextFunction<Single>() {
                    @Override
                    Single applyActual(Single s, RequestContext ctx) {
                        if (!(s instanceof Callable)) {
                            return new RequestContextSingle(s, ctx);
                        }
                        if (s instanceof ScalarCallable) {
                            return new RequestContextScalarCallableSingle(s, ctx);
                        }
                        return new RequestContextCallableSingle(s, ctx);
                    }
                }));

        oldOnMaybeAssembly = RxJavaPlugins.getOnMaybeAssembly();
        RxJavaPlugins.setOnMaybeAssembly(
                compose(oldOnMaybeAssembly, new ConditionalOnCurrentRequestContextFunction<Maybe>() {
                    @Override
                    Maybe applyActual(Maybe m, RequestContext ctx) {
                        if (!(m instanceof Callable)) {
                            return new RequestContextMaybe(m, ctx);
                        }
                        if (m instanceof ScalarCallable) {
                            return new RequestContextScalarCallableMaybe(m, ctx);
                        }
                        return new RequestContextCallableMaybe(m, ctx);
                    }
                }));

        oldOnFlowableAssembly = RxJavaPlugins.getOnFlowableAssembly();
        RxJavaPlugins.setOnFlowableAssembly(
                compose(oldOnFlowableAssembly, new ConditionalOnCurrentRequestContextFunction<Flowable>() {
                    @Override
                    Flowable applyActual(Flowable f, RequestContext ctx) {
                        if (!(f instanceof Callable)) {
                            return new RequestContextFlowable(f, ctx);
                        }
                        if (f instanceof ScalarCallable) {
                            return new RequestContextScalarCallableFlowable(f, ctx);
                        }
                        return new RequestContextCallableFlowable(f, ctx);
                    }
                }));

        oldOnConnectableFlowableAssembly = RxJavaPlugins.getOnConnectableFlowableAssembly();
        RxJavaPlugins.setOnConnectableFlowableAssembly(
                compose(oldOnConnectableFlowableAssembly,
                        new ConditionalOnCurrentRequestContextFunction<ConnectableFlowable>() {
                            @Override
                            ConnectableFlowable applyActual(
                                    ConnectableFlowable cf,
                                    RequestContext ctx) {
                                return new RequestContextConnectableFlowable(
                                        cf, ctx);
                            }
                        }
                ));

        oldOnParallelAssembly = RxJavaPlugins.getOnParallelAssembly();
        RxJavaPlugins.setOnParallelAssembly(
                compose(oldOnParallelAssembly,
                        new ConditionalOnCurrentRequestContextFunction<ParallelFlowable>() {
                            @Override
                            ParallelFlowable applyActual(ParallelFlowable pf, RequestContext ctx) {
                                return new RequestContextParallelFlowable(pf, ctx);
                            }
                        }
                ));
        enabled = true;
    }
848387
async def enable():
    """"""
    async with aiohttp.ClientSession() as session:
        data = Hole('192.168.0.215', loop, session, api_token=API_TOKEN)
        await data.enable()
310838
def enable_static_ip_config(self, ip_address, network_mask):
        
        if not isinstance(ip_address, basestring):
            raise TypeError("ip_address can only be an instance of type basestring")
        if not isinstance(network_mask, basestring):
            raise TypeError("network_mask can only be an instance of type basestring")
        self._call("enableStaticIPConfig",
                     in_p=[ip_address, network_mask])
64899
def activatePdpContextAccept(PacketDataProtocolAddress_presence=0,
                             ProtocolConfigurationOptions_presence=0):
    """"""
    a = TpPd(pd=0x8)
    b = MessageType(mesType=0x42)  # 01000010
    c = LlcServiceAccessPointIdentifier()
    d = QualityOfService()
    e = RadioPriorityAndSpareHalfOctets()
    packet = a / b / c / d / e
    if PacketDataProtocolAddress_presence is 1:
        f = PacketDataProtocolAddress(ieiPDPA=0x2B)
        packet = packet / f
    if ProtocolConfigurationOptions_presence is 1:
        g = ProtocolConfigurationOptions(ieiPCO=0x27)
        packet = packet / g
    return packet
435256
public static base_response enable(nitro_service client, String ip) throws Exception {
		dnsnameserver enableresource = new dnsnameserver();
		enableresource.ip = ip;
		return enableresource.perform_operation(client,"enable");
	}
1176723
public static nsip[] get(nitro_service service) throws Exception{
		nsip obj = new nsip();
		nsip[] response = (nsip[])obj.get_resources(service);
		return response;
	}
1190888
def activatePdpContextRequest(AccessPointName_presence=0,
                              ProtocolConfigurationOptions_presence=0):
    """"""
    a = TpPd(pd=0x8)
    b = MessageType(mesType=0x41)  # 01000001
    c = NetworkServiceAccessPointIdentifier()
    d = LlcServiceAccessPointIdentifier()
    e = QualityOfService()
    f = PacketDataProtocolAddress()
    packet = a / b / c / d / e / f
    if AccessPointName_presence is 1:
        g = AccessPointName(ieiAPN=0x28)
        packet = packet / g
    if ProtocolConfigurationOptions_presence is 1:
        h = ProtocolConfigurationOptions(ieiPCO=0x27)
        packet = packet / h
    return packet
624298
public static br_enable enable(nitro_service client, br_enable resource) throws Exception
	{
		return ((br_enable[]) resource.perform_operation(client, "enable"))[0];
	}
1308516
public static base_response update(nitro_service client, nsip resource) throws Exception {
		nsip updateresource = new nsip();
		updateresource.ipaddress = resource.ipaddress;
		updateresource.td = resource.td;
		updateresource.netmask = resource.netmask;
		updateresource.arp = resource.arp;
		updateresource.icmp = resource.icmp;
		updateresource.vserver = resource.vserver;
		updateresource.telnet = resource.telnet;
		updateresource.ftp = resource.ftp;
		updateresource.gui = resource.gui;
		updateresource.ssh = resource.ssh;
		updateresource.snmp = resource.snmp;
		updateresource.mgmtaccess = resource.mgmtaccess;
		updateresource.restrictaccess = resource.restrictaccess;
		updateresource.dynamicrouting = resource.dynamicrouting;
		updateresource.ospf = resource.ospf;
		updateresource.bgp = resource.bgp;
		updateresource.rip = resource.rip;
		updateresource.hostroute = resource.hostroute;
		updateresource.hostrtgw = resource.hostrtgw;
		updateresource.metric = resource.metric;
		updateresource.vserverrhilevel = resource.vserverrhilevel;
		updateresource.ospflsatype = resource.ospflsatype;
		updateresource.ospfarea = resource.ospfarea;
		updateresource.vrid = resource.vrid;
		updateresource.icmpresponse = resource.icmpresponse;
		updateresource.arpresponse = resource.arpresponse;
		return updateresource.update_resource(client);
	}
57985
public static base_response enable(nitro_service client, String aclname) throws Exception {
		nsacl enableresource = new nsacl();
		enableresource.aclname = aclname;
		return enableresource.perform_operation(client,"enable");
	}
116990
public boolean enable(Jid pushJid, String node)
            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
        return enable(pushJid, node, null);
    }