<pre>
Use this operation to create logical disk.
</pre>
433874
public static logical_disk add(nitro_service client, logical_disk resource) throws Exception
	{
		resource.validate("add");
		return ((logical_disk[]) resource.perform_operation(client, "add"))[0];
	}
222723
def create(self, columns=None, type_map=None, overwrite=False):
        """"""
        # Check already exists #
        if self.count_bytes > 0:
            if overwrite: self.remove()
            else: raise Exception("File exists already at '%s'" % self)
        # If we want it empty #
        if columns is None:
            self.touch()
        # Make the table #
        else:
            self.add_table(self.main_table, columns=columns, type_map=type_map)
689025
def create(self):
        
        if not os.path.exists(self.path):
            with open(self.path, 'w') as fileobj:
                fileobj.write('')
375814
public LocalFsBlobStoreFile write(String key, boolean create) throws IOException {
        return new LocalFsBlobStoreFile(getKeyDir(key), true, create);
    }
1106444
@Programmatic
    @Override
    public Command create() {
        CommandJdo command = factoryService.instantiate(CommandJdo.class);
        command.setExecutor(Executor.OTHER);
        command.setPersistence(Persistence.IF_HINTED);
        return command;
    }
1110137
public static <S> PAreaSizeBIGenerator<S> create()
  {
    final LongGenerator gen = new LongGenerator(0L, Long.MAX_VALUE);
    return new PAreaSizeBIGenerator<>(() -> new BigInteger(gen.next().toString()));
  }
1061719
private void createStorage() throws TTException {

        LOGGER.debug("Creating storage with " + mDataNumbers + " nodes containing " + BLOCKS_IN_DATA
            + " blocks with " + IStorageModule.VIRTUAL_BLOCK_SIZE + " bytes each.");

        // Creating mirror
        jCloudsStorageModule =
            new JCloudsStorageModule(BLOCKS_IN_DATA * VIRTUAL_BLOCK_SIZE, Files.createTempDir());

        IData data = this.mRtx.getCurrentData();

        if (data != null) {
            return;
        }

        for (int i = 0; i < mDataNumbers; i++) {

            // Bootstrapping nodes containing clusterSize -many blocks/sectors.
            LOGGER.debug("Bootstraping node " + i + "\tof " + (mDataNumbers - 1));
            this.mRtx.bootstrap(new byte[HybridTreetankStorageModule.BYTES_IN_DATA]);
        }

        this.mRtx.commit();
    }
530909
def create_disk(name, size):
    '''
    
    '''
    ret = False
    cmd = 'vmctl create {0} -s {1}'.format(name, size)

    result = __salt__['cmd.run_all'](cmd,
                                     output_loglevel='trace',
                                     python_shell=False)

    if result['retcode'] == 0:
        ret = True
    else:
        raise CommandExecutionError(
            'Problem encountered creating disk image',
            info={'errors': [result['stderr']], 'changes': ret}
        )

    return ret
1279852
public SymbolicLink createSymbolicLink(
      JimfsPath path, JimfsPath target, FileAttribute<?>... attrs) throws IOException {
    if (!store.supportsFeature(Feature.SYMBOLIC_LINKS)) {
      throw new UnsupportedOperationException();
    }
    return (SymbolicLink) createFile(path, store.symbolicLinkCreator(target), true, attrs);
  }
1024023
public void createHardDisk(int diskSizeMB, VirtualDiskType type, VirtualDiskMode mode) throws Exception {
        VirtualMachineConfigSpec vmConfigSpec = new VirtualMachineConfigSpec();
        VirtualDeviceConfigSpec diskSpec = new VirtualDeviceConfigSpec();

        VirtualDiskFlatVer2BackingInfo diskfileBacking = new VirtualDiskFlatVer2BackingInfo();
        diskfileBacking.setFileName("");
        diskfileBacking.setDiskMode(mode.toString());
        diskfileBacking.setThinProvisioned(type == VirtualDiskType.thin);

        VirtualSCSIController scsiController = getFirstAvailableController(VirtualSCSIController.class);
        int unitNumber = getFirstFreeUnitNumberForController(scsiController);
        VirtualDisk disk = new VirtualDisk();
        disk.setControllerKey(scsiController.key);
        disk.setUnitNumber(unitNumber);
        disk.setBacking(diskfileBacking);
        disk.setCapacityInKB(1024 * diskSizeMB);
        disk.setKey(-1);

        diskSpec.setOperation(VirtualDeviceConfigSpecOperation.add);
        diskSpec.setFileOperation(VirtualDeviceConfigSpecFileOperation.create);
        diskSpec.setDevice(disk);
        VirtualDeviceConfigSpec[] vdiskSpecArray = {diskSpec};

        vmConfigSpec.setDeviceChange(vdiskSpecArray);
        Task task = vm.reconfigVM_Task(vmConfigSpec);

        task.waitForTask(200, 100);
    }
1135128
public NfsCreateResponse create(NfsCreateMode createMode, NfsSetAttributes attributes, byte[] verifier)
            throws IOException {
        NfsCreateResponse response = getNfs().wrapped_sendCreate(getNfs().makeCreateRequest(createMode,
                getParentFile().getFileHandle(), getName(), attributes, verifier));
        setFileHandle(response.getFileHandle());
        return response;
    }
1288777
public boolean createFile() {
        try {
            try (FileWriter newDic = new FileWriter(path + "/" + name + "." + FILE_EXTENSION); BufferedWriter bufWriter = new BufferedWriter(newDic)) {
                bufWriter.write(HEAD);
                if (sentences.size() > 0) {
                    bufWriter.write("public <sentence> = (" + sentences.get(0));

                    for (int i = 1; i < sentences.size(); i++) {
                        bufWriter.write(" | " + sentences.get(i));
                    }
                    bufWriter.write(" );\n");
                }
                bufWriter.flush();
            }
            return true;
        } catch (IOException ex) {
            Logger.getLogger(GrammarFacilitator.class.getName()).log(Level.SEVERE, null, ex);
        }
        return false;
    }
453083
public static CConfiguration create() {
    // Create a new configuration instance, but do NOT initialize with
    // the Hadoop default properties.
    CConfiguration conf = new CConfiguration();
    conf.addResource("tigon-default.xml");
    conf.addResource("tigon-site.xml");
    return conf;
  }
995266
@Override
    public int writeAuxiliaryDepTables() {
        int returnCode = htod.writeAuxiliaryDepTables();
        if (returnCode == HTODDynacache.DISK_EXCEPTION) {
            stopOnError(this.htod.diskCacheException);
        } else {
            updatePropertyFile();
        }
        return returnCode;
    }
525295
public static StandardDiskConfiguration of(DiskTypeId diskType, long sizeGb) {
    return newBuilder().setDiskType(diskType).setSizeGb(sizeGb).build();
  }
321011
public void createNewFile() throws SmbException {
        if( getUncPath0().length() == 1 ) {
            throw new SmbException( "Invalid operation for workgroups, servers, or shares" );
        }
        close( open0( O_RDWR | O_CREAT | O_EXCL, 0, ATTR_NORMAL, 0 ), 0L );
    }
136823
def create_file_and_add_volume(self,
                                   runtime,          # type: List[Text]
                                   volume,           # type: MapperEnt
                                   host_outdir_tgt,  # type: Optional[Text]
                                   secret_store,     # type: Optional[SecretStore]
                                   tmpdir_prefix     # type: Text
                                   ):  # type: (...) -> Text
        """"""
        if not host_outdir_tgt:
            tmp_dir, tmp_prefix = os.path.split(tmpdir_prefix)
            new_file = os.path.join(
                tempfile.mkdtemp(prefix=tmp_prefix, dir=tmp_dir),
                os.path.basename(volume.resolved))
        writable = True if volume.type == "CreateWritableFile" else False
        if secret_store:
            contents = secret_store.retrieve(volume.resolved)
        else:
            contents = volume.resolved
        dirname = os.path.dirname(host_outdir_tgt or new_file)
        if not os.path.exists(dirname):
            os.makedirs(dirname)
        with open(host_outdir_tgt or new_file, "wb") as file_literal:
            file_literal.write(contents.encode("utf-8"))
        if not host_outdir_tgt:
            self.append_volume(runtime, new_file, volume.target,
                               writable=writable)
        if writable:
            ensure_writable(host_outdir_tgt or new_file)
        else:
            ensure_non_writable(host_outdir_tgt or new_file)
        return host_outdir_tgt or new_file