Install required components into supported hosts

    An unsupported host will still run, but may encounter issues,
    especially with threading.
11937
def install_host(use_threaded_wrapper):
    

    for install in (_install_maya,
                    _install_houdini,
                    _install_nuke,
                    _install_nukeassist,
                    _install_hiero,
                    _install_nukestudio,
                    _install_blender):
        try:
            install(use_threaded_wrapper)
        except ImportError:
            pass
        else:
            break
778520
def _work(self):
        """"""
        server = wsgi.Server(
            name=self._AGENT_BINARY,
            num_threads=CONF.AGENT.worker_count)
        server.start(
            application=_MetadataProxyHandler(),
            port=CONF.bind_port,
            host=CONF.bind_host)
        server.wait()
170766
def up(force=True, env=None, **kwargs):
    ""
    inventory = os.path.join(os.getcwd(), "hosts")
    conf = Configuration.from_dictionnary(provider_conf)
    provider = Enos_vagrant(conf)
    roles, networks = provider.init()
    check_networks(roles, networks)
    env["roles"] = roles
    env["networks"] = networks
461379
def enable_host_freshness_check(self, host):
        
        if not host.check_freshness:
            host.modified_attributes |= DICT_MODATTR["MODATTR_FRESHNESS_CHECKS_ENABLED"].value
            host.check_freshness = True
            self.send_an_element(host.get_update_status_brok())
769857
function installMapsSupport() {
  require('source-map-support').install({
    environment: 'node',
    handleUncaughtExceptions: false,
    retrieveSourceMap: (source) => {
      return sourceMapsCache.has(source) ?
             {map: sourceMapsCache.get(source), url: source} :
             null;
    },
  });
}
281461
public void setHost(String host) throws IllegalStateException {
        if (host == null) {
            throw new IllegalArgumentException("host parameter is null");
        }
        assertNotOpen();
        hostName = host;
    }
1371598
def install(self, host):
        """"""
        print("Installing..")
        if self._state["installed"]:
            return

        if self.is_headless():
            log.info("Headless host")
            return

        print("aboutToQuit..")
        self.app.aboutToQuit.connect(self._on_application_quit)

        if host == "Maya":
            print("Maya host..")
            window = {
                widget.objectName(): widget
                for widget in self.app.topLevelWidgets()
            }["MayaWindow"]

        else:
            window = self.find_window()

        # Install event filter
        print("event filter..")
        event_filter = self.EventFilter(window)
        window.installEventFilter(event_filter)

        for signal in SIGNALS_TO_REMOVE_EVENT_FILTER:
            pyblish.api.register_callback(signal, self.uninstall)

        log.info("Installed event filter")

        self.window = window
        self._state["installed"] = True
        self._state["eventFilter"] = event_filter
648433
def run(cls):
        
        if not all(v is None for v in cls._services.values()):
            cls._set_host_id()
            cls._setup_logging()
            cls._set_process_name()
            cls._set_signal_handlers()
            cls._start_server()
        else:
            cls._logger.error('No services to host')
207012
def apply_dependencies(self):
        
        self.hosts.apply_dependencies()
        self.services.apply_dependencies(self.hosts)
287095
def apply_dependencies(self, hosts):
        
        for service in self:
            if service.host and service.host_dependency_enabled:
                host = hosts[service.host]
                if host.active_checks_enabled:
                    service.act_depend_of.append(
                        (service.host, ['d', 'x', 's', 'f'], '', True)
                    )
                    host.act_depend_of_me.append(
                        (service.uuid, ['d', 'x', 's', 'f'], '', True)
                    )
                    host.child_dependencies.add(service.uuid)
                    service.parent_dependencies.add(service.host)
480617
def set_host(self, host):
        
        if host[-1] == '/':
            host = host[:-1]

        self.host = host
        return self
775521
def add_connection(self, host):
        
        self.hosts.append(host)
        self.set_connections(self.hosts)
1220926
public function allowOne($host)
    {
        return $this->exists($host)
            ? $this->updateOne($host, false)
            : $this->addOne($host, false);
    }
1024476
def addHost(self, name=None):
        '''
        
        '''
        if name is None:
            while True:
                name = 'h' + str(self.__hnum)
                self.__hnum += 1
                if name not in self.__nxgraph:
                    break
        self.__addNode(name, Host)
        return name
503149
@Override
    protected void doExecute() throws Exception {
        if (skip) {
            return;
        }

        if (features == null) {
            // For liberty-assembly integration:
            // When using installUtility, if no features section was specified, 
            // then don't install features because it requires license acceptance
            noFeaturesSection = true;
            
            // initialize features section for all scenarios except for the above
            features = new Features();
        }

        checkServerHomeExists();
        installFeatures();
    }
256382
def add_vhost(vhost, runas=None):
    '''
    
    '''
    if runas is None and not salt.utils.platform.is_windows():
        runas = salt.utils.user.get_user()
    res = __salt__['cmd.run_all'](
        [RABBITMQCTL, 'add_vhost', vhost],
        reset_system_locale=False,
        runas=runas,
        python_shell=False)

    msg = 'Added'
    return _format_response(res, msg)
281378
public final void setHost(final String host) throws UnknownHostException {
        this.host = host;
        final InetAddress[] inetAddresses = InetAddress.getAllByName(host);

        for (InetAddress address: inetAddresses) {
            final AddressHostMatcher matcher = new AddressHostMatcher();
            matcher.setIp(address.getHostAddress());
            this.matchersForHost.add(matcher);
        }
    }