Set Startup Disk
 Only Supports 'Specify Local Startup Disk' at the moment

 @param startup_disk_option[String]

 @return [void]
320276
def startup_disk=(startup_disk_option)
      raise JSS::InvalidDataError, "#{startup_disk_option} is not a valid Startup Disk" unless startup_disk_option.is_a? String
      @reboot_options[:startup_disk] = 'Specify Local Startup Disk'
      self.specify_startup = startup_disk_option
      @need_to_update = true
    end
528678
def set_as_default(options = {})
      options = options.merge(
        policy_arn: @arn,
        version_id: @version_id
      )
      resp = @client.set_default_policy_version(options)
      resp.data
    end
107108
def init
      File.exist?(EXCLUDE_FILE) ? @logger.info('skip: creation excludes.d') : create_exclude_config
      Dir.exist?(ROLE_DIR) ? @logger.info('skip: creation roles.d') : create_roles_dir
      Dir.exist?(USER_DIR) ? @logger.info('skip: creation users.d') : create_users_dir
    end
684426
boolean setStart(ArgTokenizer at) {
        at.allowedOptions("-default", "-none", "-retain");
        List<String> fns = new ArrayList<>();
        while (at.next() != null) {
            fns.add(at.val());
        }
        if (!checkOptionsAndRemainingInput(at)) {
            return false;
        }
        boolean defaultOption = at.hasOption("-default");
        boolean noneOption = at.hasOption("-none");
        boolean retainOption = at.hasOption("-retain");
        boolean hasFile = !fns.isEmpty();

        int argCount = (defaultOption ? 1 : 0) + (noneOption ? 1 : 0) + (hasFile ? 1 : 0);
        if (argCount > 1) {
            errormsg("jshell.err.option.or.filename", at.whole());
            return false;
        }
        if (argCount == 0 && !retainOption) {
            // no options or filename, show current setting
            showSetStart();
            return true;
        }
        if (hasFile) {
            startup = Startup.fromFileList(fns, "/set start", this);
            if (startup == null) {
                return false;
            }
        } else if (defaultOption) {
            startup = Startup.defaultStartup(this);
        } else if (noneOption) {
            startup = Startup.noStartup();
        }
        if (retainOption) {
            // retain startup setting
            prefs.put(STARTUP_KEY, startup.storedForm());
        }
        return true;
    }
885474
def set_one_time_boot(self, device):
        
        sushy_system = self._get_sushy_system(PROLIANT_SYSTEM_ID)
        # Check if the input is valid
        if device.upper() not in DEVICE_COMMON_TO_REDFISH:
            msg = (self._('Invalid input "%(device)s". Valid devices: '
                          'NETWORK, HDD, ISCSI or CDROM.') %
                   {'device': device})
            raise exception.IloInvalidInputError(msg)

        try:
            sushy_system.update_persistent_boot(
                [device], persistent=False)
        except sushy.exceptions.SushyError as e:
            msg = (self._('The Redfish controller failed to set '
                          'one time boot device %(device)s. '
                          'Error: %(error)s') %
                   {'device': device, 'error': str(e)})
            LOG.debug(msg)
            raise exception.IloError(msg)
1122881
def init_volume(self, fstype=None):
        

        logger.debug("Initializing volume {0}".format(self))

        if not self._should_mount():
            return False

        if self.flag != 'alloc':
            return False

        if self.info.get('raid_status') == 'waiting':
            logger.info("RAID array %s not ready for mounting", self)
            return False

        if self.is_mounted:
            logger.info("%s is currently mounted, not mounting it again", self)
            return False

        logger.info("Mounting volume {0}".format(self))
        self.mount(fstype=fstype)
        self.detect_mountpoint()

        return True
376497
void setStartCluster(long startCluster) {
        if (startCluster > Integer.MAX_VALUE) throw new AssertionError();

        if (this.type == FatType.FAT32) {
            LittleEndian.setInt16(data, 0x1a, (int) (startCluster & 0xffff));
            LittleEndian.setInt16(data, 0x14, (int) ((startCluster >> 16) & 0xffff));
        } else {
            LittleEndian.setInt16(data, 0x1a, (int) startCluster);
        }
    }
1188789
def start(name, call=None):
    '''
    
    '''
    if call != 'action':
        raise SaltCloudException(
            'The start action must be called with -a or --action.'
        )

    node_id = get_linode_id_from_name(name)
    node = get_linode(kwargs={'linode_id': node_id})

    if node['STATUS'] == 1:
        return {'success': True,
                'action': 'start',
                'state': 'Running',
                'msg': 'Machine already running'}

    response = _query('linode', 'boot', args={'LinodeID': node_id})['DATA']

    if _wait_for_job(node_id, response['JobID']):
        return {'state': 'Running',
                'action': 'start',
                'success': True}
    else:
        return {'action': 'start',
                'success': False}
106132
def initializenb():
    

    logger.info('Working directory: {0}'.format(os.getcwd()))
    logger.info('Run on {0}'.format(asctime()))
    try:
        fileroot = os.environ['fileroot']
        logger.info('Setting fileroot to {0} from environment variable.\n'.format(fileroot))
        candsfile = 'cands_{0}_merge.pkl'.format(fileroot)
        noisefile = 'noise_{0}_merge.pkl'.format(fileroot)
    except KeyError:
        sdmdir = os.getcwd()
        logger.info('Setting sdmdir to current directory {0}\n'.format(os.path.abspath(sdmdir)))
        candsfiles = glob.glob('cands_*_merge.pkl')
        noisefiles = glob.glob('noise_*_merge.pkl')
        if len(candsfiles) == 1 and len(noisefiles) == 1:
            logger.info('Found one cands/merge file set')
        else:
            logger.warn('Found multiple cands/noise file sets. Taking first.')

        candsfile = candsfiles[0]
        noisefile = noisefiles[0]
        fileroot = candsfile.rstrip('_merge.pkl').lstrip('cands_')
    logger.info('Set: \n\t candsfile {} \n\t noisefile {} \n\t fileroot {} '.format(candsfile, noisefile, fileroot))
    return (candsfile, noisefile, fileroot)
546574
def set_uefi_shell_startup(uefi_shell_startup, uefi_shell_startup_location, uefi_shell_startup_url)
      new_action = {
        'UefiShellStartup' => uefi_shell_startup,
        'UefiShellStartupLocation' => uefi_shell_startup_location,
        'UefiShellStartupUrl' => uefi_shell_startup_url
      }
      response = rest_patch('/redfish/v1/Systems/1/bios/Settings/', body: new_action)
      response_handler(response)
      true
    end
659527
def open(_mode = "rb")
      # NTFS module methods use miqfs instance accessors to
      # touch @boot_sector, @drive_root, @index_cache and @cache_hits
      # (and any other NTFS members that may come later)
      @din = ifs_getFile(@path, @miqfs)
      raise "File not found: '#{@path}'"    if @din.nil?
      mft_entry = @din.resolve(@miqfs.boot_sector)
      raise "File is directory: '#{@path}'" if @din.isDir?
      @data = mft_entry.attributeData || AttribData.new("", 0)
    end
719002
def set_url_boot_file(url_boot_file)
      new_action = { 'UrlBootFile' => url_boot_file }
      response = rest_patch('/redfish/v1/Systems/1/bios/Settings/', body: new_action)
      response_handler(response)
      true
    end
1352156
func (o *Disk) SetBoot(v *bool) *Disk {
	if o.Boot = v; o.Boot == nil {
		o.nullFields = append(o.nullFields, "Boot")
	}
	return o
}
372034
def on_startup(self):
        

        LOGGER.debug("> Calling '{0}' Component Framework 'on_startup' method.".format(self.__class__.__name__))

        if self.Autostart_TCP_Server_checkBox.isChecked():
            if not self.__tcp_server.online:
                self.__tcp_server.port = self.Port_spinBox.value()
                self.__tcp_server.start()
        return True
657376
def setup_default_options
      opts = {}
      MsRestAzure::Common::Configurable.keys.map do |key|
        opts[key] = MsRestAzure::Common::Default.options[key]
      end

      opts
    end
397605
private void setToRowStart(RowIndexEntry rowEntry, FileDataInput in) throws IOException
    {
        if (in == null)
        {
            this.file = sstable.getFileDataInput(rowEntry.position);
        }
        else
        {
            this.file = in;
            in.seek(rowEntry.position);
        }
        sstable.partitioner.decorateKey(ByteBufferUtil.readWithShortLength(file));
    }
136613
async def set_as_boot_disk(self):
        """"""
        await self._handler.set_boot_disk(
            system_id=self.node.system_id, id=self.id)