bucket_buckets - CSDN
精华内容
参与话题
  • 存储空间(Bucket

    万次阅读 2017-08-09 16:08:06
    存储空间(Bucket) 存储空间是您用于存储对象(Object)的容器,所有的对象都必须隶属于某个存储空间。您可以设置和修改存储空间属性用来控制地域、访问权限、生命周期等,这些属性设置直接作用于该存储空间内所有...

    存储空间(Bucket)

    存储空间是您用于存储对象(Object)的容器,所有的对象都必须隶属于某个存储空间。您可以设置和修改存储空间属性用来控制地域、访问权限、生命周期等,这些属性设置直接作用于该存储空间内所有对象,因此您可以通过灵活创建不同的存储空间来完成不同的管理功能。

    同一个存储空间的内部是扁平的,没有文件系统的目录等概念,所有的对象都直接隶属于其对应的存储空间。

     每个用户可以拥有多个存储空间

    存储空间的名称在 OSS 范围内必须是全局唯一的,一旦创建之后无法修改名称。

    存储空间内部的对象数目没有限制。


    存储空间的命名规范如下:

    只能包括小写字母、数字和短横线(-)。
    必须以小写字母或者数字开头和结尾。
    长度必须在3-63字节之间。

    展开全文
  • HashMap 里的“bucket”、“负载因子” 介绍

    万次阅读 多人点赞 2016-10-04 19:01:41
    【以下内容摘抄自 ...对于 HashMap 及其子类而言,它们采用 Hash 算法来决定集合中元素的存储位置。当系统开始初始化 HashMap 时,系统会... bucket 都有其指定索引,系统可以根据其索引快速访问该 bucket 里存储的元素。

    【以下内容摘抄自点击打开链接 末尾几段】

    对于 HashMap 及其子类而言,它们采用 Hash 算法来决定集合中元素的存储位置。当系统开始初始化 HashMap 时,系统会创建一个长度为 capacity 的 Entry 数组,这个数组里可以存储元素的位置被称为“桶(bucket)”,每个 bucket 都有其指定索引,系统可以根据其索引快速访问该 bucket 里存储的元素。 


    无论何时,HashMap 的每个“桶”只存储一个元素(也就是一个 Entry),由于 Entry 对象可以包含一个引用变量(就是 Entry 构造器的的最后一个参数)用于指向下一个 Entry,因此可能出现的情况是:HashMap 的 bucket 中只有一个 Entry,但这个 Entry 指向另一个 Entry ——这就形成了一个 Entry 链。如图 1 所示: 

     

    图 1. HashMap 的存储示意 

    HashMap 的读取实现 

    当 HashMap 的每个 bucket 里存储的 Entry 只是单个 Entry ——也就是没有通过指针产生 Entry 链时,此时的 HashMap 具有最好的性能:当程序通过 key 取出对应 value 时,系统只要先计算出该 key 的 hashCode() 返回值,在根据该 hashCode 返回值找出该 key 在 table 数组中的索引,然后取出该索引处的 Entry,最后返回该 key 对应的 value 即可。看 HashMap 类的 get(K key) 方法代码: 

    Java代码  收藏代码
    1. public V get(Object key)   
    2. {   
    3.  // 如果 key 是 null,调用 getForNullKey 取出对应的 value   
    4.  if (key == null)   
    5.      return getForNullKey();   
    6.  // 根据该 key 的 hashCode 值计算它的 hash 码  
    7.  int hash = hash(key.hashCode());   
    8.  // 直接取出 table 数组中指定索引处的值,  
    9.  for (Entry<K,V> e = table[indexFor(hash, table.length)];   
    10.      e != null;   
    11.      // 搜索该 Entry 链的下一个 Entr   
    12.      e = e.next)         // ①  
    13.  {   
    14.      Object k;   
    15.      // 如果该 Entry 的 key 与被搜索 key 相同  
    16.      if (e.hash == hash && ((k = e.key) == key   
    17.          || key.equals(k)))   
    18.          return e.value;   
    19.  }   
    20.  return null;   
    21. }   



    从上面代码中可以看出,如果 HashMap 的每个 bucket 里只有一个 Entry 时,HashMap 可以根据索引、快速地取出该 bucket 里的 Entry;在发生“Hash 冲突”的情况下,单个 bucket 里存储的不是一个 Entry,而是一个 Entry 链,系统只能必须按顺序遍历每个 Entry,直到找到想搜索的 Entry 为止——如果恰好要搜索的 Entry 位于该 Entry 链的最末端(该 Entry 是最早放入该 bucket 中),那系统必须循环到最后才能找到该元素。 

    归纳起来简单地说,HashMap 在底层将 key-value 当成一个整体进行处理,这个整体就是一个 Entry 对象。HashMap 底层采用一个 Entry[] 数组来保存所有的 key-value 对,当需要存储一个 Entry 对象时,会根据 Hash 算法来决定其存储位置;当需要取出一个 Entry 时,也会根据 Hash 算法找到其存储位置,直接取出该 Entry。由此可见:HashMap 之所以能快速存、取它所包含的 Entry,完全类似于现实生活中母亲从小教我们的:不同的东西要放在不同的位置,需要时才能快速找到它。 

    当创建 HashMap 时,有一个默认的负载因子(load factor),其默认值为 0.75,这是时间和空间成本上一种折衷:增大负载因子可以减少 Hash 表(就是那个 Entry 数组)所占用的内存空间,但会增加查询数据的时间开销,而查询是最频繁的的操作(HashMap 的 get() 与 put() 方法都要用到查询);减小负载因子会提高数据查询的性能,但会增加 Hash 表所占用的内存空间。 

    掌握了上面知识之后,我们可以在创建 HashMap 时根据实际需要适当地调整 load factor 的值;如果程序比较关心空间开销、内存比较紧张,可以适当地增加负载因子;如果程序比较关心时间开销,内存比较宽裕则可以适当的减少负载因子。通常情况下,程序员无需改变负载因子的值。 

    如果开始就知道 HashMap 会保存多个 key-value 对,可以在创建时就使用较大的初始化容量,如果 HashMap 中 Entry 的数量一直不会超过极限容量(capacity * load factor),HashMap 就无需调用 resize() 方法重新分配 table 数组,从而保证较好的性能。当然,开始就将初始容量设置太高可能会浪费空间(系统需要创建一个长度为 capacity 的 Entry 数组),因此创建 HashMap 时初始化容量设置也需要小心对待。 
    展开全文
  • Ceph学习之Crush算法—— Bucket

    千次阅读 2015-08-01 21:52:23
    CRUSH定义了四种bucket类型(Uniform Bucket、List Bucket、Tree Bucket、Straw Bucket)来表示层级结构的中间节点,叶子节点就是对应的OSD。每一种类型的bucket使用不同的数据结构来组织它包含的内容,可以是其他...

    Ceph使用Bucket将系统的存储资源按照层级结构组织完成两个目标:映射算法的高效性和可扩展性,以及当集群状态发生变化时(比如设备的增加或者删除)数据的迁移量要尽可能的少。CRUSH定义了四种bucket类型(Uniform Bucket、List Bucket、Tree Bucket、Straw Bucket)来表示层级结构的中间节点,叶子节点就是对应的OSD。每一种类型的bucket使用不同的数据结构来组织它包含的内容,可以是其他Bucket或者OSD,它们是在性能和效率间的折中。接下来将详细介绍一下这四种Bucket。

    1 Uniform Bucket

    这种bucket有一个严格的要求,bucket中所有的item都是同构的,如有相同的性能,相同大小的容量,而其余三种bucket允许包含不同权重的设备。这个主要是考虑到设备不会一个一个添加到系统里,而是批量添加的。它根据hash函数c(r,x)=(hash(x) + rp) mod m进行映射,映射的时间复杂度是O(1),所以它的查询速度是最快的。当然它也有明显的不足,当添加或删除item时,会导致大量的数据迁移。这是因为它的计算方法和bucket大小有关系,所以当bucket发生变化时所有的计算结果都会发生变化,也就是会有数据迁移。

    2 List Bucket

    它的结构是链表结构,所包含的item可以具有任意的权重。CRUSH从表头开始查找副本位置,它先得到表头item的权重Wh,然后和剩余所有节点权重之和Wr做比较,然后根据hash(x, r, item)得到一个[0~1]值v,如果v在[0~Wh/Wr],则副本在表头item中,并返回item的id,否则继续遍历剩余的链表。这个方法是从RUSHp算法中演变过来的,将数据分布问题转变为“most recently added item, or older items”。这种方法对于总是有新节点加入的情况很有好处,但当有节点从中间或者尾部删除时,就会带来一些数据迁移。这也和它的计算方法有关系,如果从尾部删除一个节点后,Wr的值回发生变化,所以ratio的值也会发生变化。使用这种bucket会使得数据要么存储在新加入的节点上,要么就还保留在原来老的地方。

    List Bucket的查找复杂度为O(n),所以只适用于规模比较小的集群。

    3 Tree Bucket

    该方法是从RUSHt演化过来的,主要是为了解决规模比较大的环境,查找复杂度为O(logn)。Tree buckets中的元素被组织成一个加权的二叉查找树,所有的项都位于叶子节点。每一个内部节点都知道他左右子树的权重,并且按照固定的策略打上标签。

    当需要从bucket众选出一项时,CRUSH从root节点开始查找副本的位置,它先得到节点的左子树的权重Wl,得到节点的权重Wn,然后根据hash(x, r, node_id)得到一个[0~1]的值v,假如这个值v在[0~Wl/Wn)中,则副本在左子树中,否者在右子树中。继续遍历节点,直到到达叶子节点。Tree Bucket的关键是当添加删除叶子节点时,决策树中的其他节点的node_id不变。二叉树中节点的node_id的标识是根据对二叉树的中序遍历来决定的(node_id不等于item的id,也不等于节点的权重)。

    二叉树的节点的标签方法使用的是一个简单固定的方法以避免树中有节点增加或者节点减少而导致其他节点标签的变化。这个规则很简单:
    1)树中最左侧的叶子节点永远是1
    2)每次树增长的时候都会产生一个的新的根节点,之前的根节点会变成新根节点的左孩子。新的根节点的标签等于老的根节点的标签向左移一位(1,10,100,etc)。树的右侧的标签会复制左侧节点的标签并在最左侧在加上一个1。

    tree bucket在查询性能上相比于list要好,而且数据迁移的控制也比较好。当一个节点发生变化时,只会导致节点所在子树上发生数据迁移。

    4 Straw Bucket

    这种类型让Bucket所包含的所有item公平的竞争(不像list和tree一样需要遍历)。这种算法就像抽签一样,所有的item都有机会被抽中(只有最长的签才能被抽中)。每个签的长度是由f(Wi)*hash(x, r, i) 决定的,Wi是item i的权重,i是item的id号。c(r, x) = MAX(f(Wi) * hash(x, r, i))。目前,这种Bucket是Ceph默认使用的Bucket,所以它也是经过大规模测试的,稳定性较好。虽然它的查询性能不如List和Tree,但它在控制数据迁移方面是最优的。

    展开全文
  • [阿里OSS存储对象之Bucket访问]

    万次阅读 2018-06-01 12:53:02
    Bucket是OSS上的命名空间,权限控制、日志记录等高级功能的管理实体;Bucket名称在整个OSS服务中具有全局唯一性,且不能修改;存储在OSS上的每个Object必须都包含在某个Bucket中。一个应用,例如图片分享网站,可以...

           Bucket是OSS上的命名空间,权限控制、日志记录等高级功能的管理实体;Bucket名称在整个OSS服务中具有全局唯一性,且不能修改;存储在OSS上的每个Object必须都包含在某个Bucket中。一个应用,例如图片分享网站,可以对应一个或多个Bucket。一个用户最多可创建10个Bucket,但每个Bucket中存放的Object的数量和大小总和没有限制,用户不需要考虑数据的可扩展性。

        Bucket的创建,删除,访问代码如下:

    /**
     * 阿里对象存储OSS数据管理
     * */
    public class AliOSSClientEx extends OSSClient {
    private static final Log log = LogFactory.getLog(AliOSSClientEx.class);


    private ServiceClient serviceClientEx;
    private LiveChannelOperationEx liveChannelOperationEx;
    private String endPoint;
    private String bucketName;


    /**
    * Create one OSSClient object
    * */
    public static AliOSSClientEx getOSSClient(String bucketName, String endPoint, String accessKeyId,
    String accessKeySecret) {
    try {
    ClientConfiguration conf = new ClientConfiguration();
    // 设置OSSClient使用的最大连接数,默认1024
    conf.setMaxConnections(512);
    // 设置请求超时时间,默认50秒
    conf.setSocketTimeout(60 * 1000);
    // 设置失败请求重试次数,默认3次
    conf.setMaxErrorRetry(3);
    DefaultCredentialProvider credentialProvider = new DefaultCredentialProvider(accessKeyId, accessKeySecret);
    AliOSSClientEx ossClient = new AliOSSClientEx(bucketName, endPoint, credentialProvider, conf);
    return ossClient;
    } catch (Throwable t) {
    log.error("Create Ali OSSClient exception," + endPoint, t);
    return null;
    }
    }


    public AliOSSClientEx(String bucketName, String endPoint, DefaultCredentialProvider credentialProvider,
    ClientConfiguration conf) {
    super(endPoint, credentialProvider, conf);
    this.bucketName = bucketName;
    this.endPoint = endPoint;
    this.initOperations(conf, credentialProvider);
    }


    /**
    * @param bucketName
    * */
    public String createOSSBucket(String bucketName) throws Exception {
    try {
    Bucket bucket = null;
    if (!super.doesBucketExist(bucketName)) {
    bucket = super.createBucket(new CreateBucketRequest(bucketName));
    return bucket.getName() + "." + endPoint;
    } else {
    BucketInfo bucketInfo = getBucketInfo(bucketName);
    return bucketInfo.getBucket().getName() + "." + endPoint;
    }
    } catch (Exception ex) {
    log.error("Create bucket exception:", ex);
    throw ex;
    }
    }


    /**
    * @param bucketName
    * */
    public boolean deleteOSSBucket(String bucketName) {
    try {
    if (super.doesBucketExist(bucketName)) {
    super.deleteBucket(bucketName);
    return true;
    }
    } catch (Exception ex) {
    log.error("Delete bucket exception", ex);
    }
    return false;
    }


    public boolean isBucketExists(String bucketName) {
    List<Bucket> buckets = listBuckets();
    if (buckets != null) {
    for (Bucket bucket : buckets) {
    if (bucketName.equals(bucket.getName())) {
    return true;
    }
    }
    }
    return false;
    }


    /**
    * @param liveChannelName

    * @return 返回推流地址
    * */
    public String createLiveChannel(String liveChannelName) throws Exception {
    try {
    CreateLiveChannelRequest liveChannelRequest = new CreateLiveChannelRequest(bucketName, liveChannelName);
    CreateLiveChannelResult liveChannelResult = super.createLiveChannel(liveChannelRequest);
    List<String> urls = liveChannelResult.getPublishUrls();
    if (urls != null && urls.size() > 0) {
    return urls.get(0);
    }
    return null;
    } catch (Exception ex) {
    log.error("Create default live channel exception,liveChannel=" + liveChannelName, ex);
    throw ex;
    }
    }


    /**
    * @param liveChannelName
    * @return 返回指定LiveChannel最近的10次推流记录
    * */
    public List<LiveRecord> getLiveChannelHistory(String liveChannelName) {
    try {
    List<LiveRecord> liveRecords = super.getLiveChannelHistory(bucketName, liveChannelName);
    return liveRecords;
    } catch (Exception ex) {
    log.error("Get live channel history record exception,liveChannel=" + liveChannelName, ex);
    return null;
    }
    }


    /**

    * @param liveChannelName
    * @return 获取指定LiveChannel的推流状态信息。

    * */
    public LiveChannelStat getLiveChannelStat(String liveChannelName) {
    try {
    LiveChannelStat stat = super.getLiveChannelStat(bucketName, liveChannelName);
    return stat;
    } catch (Exception ex) {
    log.error("Get live channel state exception,liveChannel=" + liveChannelName, ex);
    return null;
    }
    }


    /**
    * @param liveChannelName
    * @return 获取指定LiveChannel的配置信息
    * */
    public LiveChannelInfo getLiveChannelInfo(String liveChannelName) {
    try {
    LiveChannelInfo channelInfo = super.getLiveChannelInfo(bucketName, liveChannelName);
    return channelInfo;
    } catch (Exception ex) {
    log.error("Get live channel info exception,liveChannel=" + liveChannelName, ex);
    return null;
    }
    }


    /**
    * 获取Backet下的所有liveChannels

    * @return
    * */
    public List<LiveChannel> getLiveChannels() {
    try {
    List<LiveChannel> channels = super.listLiveChannels(bucketName);
    return channels;
    } catch (Exception ex) {
    log.error("Get bucket live channels exception.", ex);
    return null;
    }
    }


    /**
    * 设置LiveChanel存储对象的生命周期,Lifecycle开启后,OSS将按照配置,
    * 定期自动删除或转储与Lifecycle规则相匹配的Object。

    * @param liveChannelName
    *            :

    * @param days
    *            :指定规则在对象最后修改时间过后多少天生效。

    * */
    public boolean setChannelLifecycle(String channelId, String liveChannelName, int days) {
    try {
    SetBucketLifecycleRequest lifecycleRequest = new SetBucketLifecycleRequest(bucketName);
    LifecycleRule lifecycleRule = new LifecycleRule();
    lifecycleRule.setId(channelId);
    lifecycleRule.setExpirationDays(days);
    lifecycleRule.setPrefix(liveChannelName + "/");
    lifecycleRule.setStatus(RuleStatus.Enabled);
    lifecycleRequest.AddLifecycleRule(lifecycleRule);
    this.setBucketLifecycle(lifecycleRequest);
    return true;
    } catch (Exception ex) {
    log.error("Set live channel object life cycle exception,liveChannel=" + liveChannelName, ex);
    return false;
    }
    }


    /**
    * 删除LiveChanel存储对象的生命周期,实际上并不是真正的删除,而是把生命周期规则设备为无效

    * @param liveChannelName
    *            :

    * */
    public boolean deleteChannelLifecycle(String channelId, String liveChannelName) {
    try {
    SetBucketLifecycleRequest lifecycleRequest = new SetBucketLifecycleRequest(bucketName);
    LifecycleRule lifecycleRule = new LifecycleRule();
    lifecycleRule.setId(channelId);
    lifecycleRule.setExpirationDays(99999);
    lifecycleRule.setPrefix(liveChannelName + "/");
    lifecycleRule.setStatus(RuleStatus.Disabled);
    lifecycleRequest.AddLifecycleRule(lifecycleRule);
    this.setBucketLifecycle(lifecycleRequest);
    return true;
    } catch (Exception ex) {
    log.error("Set live channel object life cycle exception,liveChannel=" + liveChannelName, ex);
    return false;
    }
    }


    /**
    * 用来为指定LiveChannel推流生成的,指定时间段内的ts文件生成一个点播用的播放列表(m3u8文件)

    * @param liveChannelName
    * @param playListName
    * @param startTime
    *            :开始时间 Unix timestamp(秒)
    * @param entTime
    *            :结束时间 Unix timestamp(秒) endTime必须大于startTime,且时间跨度不能大于1天。

    * @return OSS会查询指定时间范围内的所有该LiveChannel推流生成的ts文件,并将其拼装为一个播放列表
    * @throws Exception
    * */
    public VodResult postVodPlaylist(String liveChannelName, String playListName, long startTime, long endTime)
    throws Exception {
    if (startTime >= endTime) {
    throw new Exception("Start time must be less than the end time.");
    }
    if ((endTime - startTime) >= 24 * 3600) {
    throw new Exception("The time span of the start and end times cannot be greater than one day.");
    }


    try {
    GenerateVodPlaylistRequest generateVodPlaylistRequest = new GenerateVodPlaylistRequest(bucketName,
    liveChannelName, playListName, startTime, endTime);
    return liveChannelOperationEx.generateVodPlaylistEx(generateVodPlaylistRequest);
    } catch (Exception ex) {
    log.error("Get vod play list exception,liveName=" + liveChannelName + ",playListName=" + playListName, ex);
    return null;
    }
    }


    /**
    * 获取指定的LiveChannel下的所有ts文件

    * @param liveChannel
    *            :
    * @param prefix
    *            :限定返回的object key必须以prefix作为前缀
    * @return List<ChannelFileSummary>
    * */
    public List<ChannelFileSummary> getLiveChannelFiles(String liveChannel, String prefix) {
    return getLiveChannelFiles(liveChannel, prefix, null);
    }


    /**
    * 获取指定的LiveChannel下的所有ts文件

    * @param liveChannel
    *            :
    * @param prefix
    *            : 限定返回的object key必须以prefix作为前缀。
    * @param marker
    *            :设定结果从marker之后按字母排序的第一个开始返回

    * */
    public List<ChannelFileSummary> getLiveChannelFiles(String liveChannel, String prefix, String marker) {
    try {
    final int maxKeys = 999;
    List<ChannelFileSummary> fileSummaries = new ArrayList<ChannelFileSummary>();
    ListObjectsRequest objectsRequest = new ListObjectsRequest(bucketName);
    objectsRequest.setMaxKeys(maxKeys);
    objectsRequest.setPrefix(liveChannel + "/" + prefix);
    objectsRequest.setMarker(marker);
    ObjectListing objectListing = super.listObjects(objectsRequest);
    if (objectListing.getObjectSummaries().size() > 0) {
    ChannelFileSummary fileSummary = null;
    for (OSSObjectSummary objectSummary : objectListing.getObjectSummaries()) {
    fileSummary = new ChannelFileSummary(objectSummary);
    if (liveChannel.equals(fileSummary.getChannelName())) {
    fileSummaries.add(fileSummary);
    }
    }
    }
    return fileSummaries;
    } catch (Exception ex) {
    log.error("Get live channel files exception,liveChannel=" + liveChannel, ex);
    return null;
    }
    }


    /**
    * 查询小时内的所有.ts文件

    * @param liveChannel
    *            :
    * @param dateHour
    *            :
    * @return List<ChannelFileSummary>
    * */
    public List<ChannelFileSummary> getLiveChannelFilesByTime(String liveChannel, Date dateHour) {
    Calendar beginCalendar = Calendar.getInstance();
    beginCalendar.setTime(dateHour);
    beginCalendar.set(Calendar.MINUTE, 0);
    beginCalendar.set(Calendar.SECOND, 0);
    beginCalendar.add(Calendar.MILLISECOND, 0);


    Calendar endCalendar = Calendar.getInstance();
    endCalendar.setTime(dateHour);
    endCalendar.set(Calendar.MINUTE, 59);
    endCalendar.set(Calendar.SECOND, 59);
    endCalendar.add(Calendar.MILLISECOND, 999);
    return getLiveChannelFilesByTime(liveChannel, beginCalendar.getTime(), endCalendar.getTime());
    }


    /**
    * 查询指定的时间范围内的.ts文件

    * @param liveChannel
    *            :
    * @param beginTime
    *            :
    * @param endTime
    *            :
    * @return List<ChannelFileSummary>
    * */
    public List<ChannelFileSummary> getLiveChannelFilesByTime(String liveChannel, Date beginTime, Date endTime) {
    List<String> lstTimeRange = getTimeRange(beginTime, endTime);
    long startTimestamp = beginTime.getTime();
    long endTimestamp = endTime.getTime();
    List<ChannelFileSummary> channelFileSummaries = new ArrayList<ChannelFileSummary>();
    List<ChannelFileSummary> tempFileSummaries = null;
    for (String timePrefix : lstTimeRange) {
    tempFileSummaries = getLiveChannelFiles(liveChannel, timePrefix);
    if (tempFileSummaries != null) {
    for (ChannelFileSummary fileSummary : tempFileSummaries) {
    if (fileSummary.getFileTimestamp() > 0) {
    if (fileSummary.getFileTimestamp() >= startTimestamp
    && fileSummary.getFileTimestamp() <= endTimestamp) {
    channelFileSummaries.add(fileSummary);
    }
    }
    }
    }
    }


    return channelFileSummaries;
    }


    /**
    * @param liveChannelName

    * @param playListName

    * @return 返回推流地址
    * */
    public String createLiveChannel(String liveChannelName, String playListName) {
    try {
    LiveChannelTarget target = new LiveChannelTarget("HLS", 100, 99, playListName);
    CreateLiveChannelRequest createLiveChannelRequest = new CreateLiveChannelRequest(bucketName,
    liveChannelName, "", LiveChannelStatus.Enabled, target);


    CreateLiveChannelResult createLiveChannelResult = super.createLiveChannel(createLiveChannelRequest);
    List<String> urls = createLiveChannelResult.getPublishUrls();
    if (urls != null && urls.size() > 0) {
    return urls.get(0);
    }
    } catch (Exception ex) {
    log.error("Create target live channel exception,liveChannel=" + liveChannelName + ",playListName="
    + playListName, ex);
    }
    return null;
    }


    /**
    * @param liveChannelName
    * @return true:success,false:
    * */
    public boolean deleteLiveChannel(String liveChannelName) {
    try {
    LiveChannelGenericRequest liveChannelRequest = new LiveChannelGenericRequest(bucketName, liveChannelName);
    super.deleteLiveChannel(liveChannelRequest);
    return true;
    } catch (Exception ex) {
    log.error("Delete live channel exception,liveChannel=" + liveChannelName, ex);
    return false;
    }
    }


    /**
    * @param liveChannelName
    *
    * @param playListName
    * @return rtmp地址
    * */
    public String getSignRtmpUrl(String liveChannelName, String playListName) {
    // 设置URL过期时间为1小时
    return getSignRtmpUrl(liveChannelName, playListName, 24 * 3600 * 1000);
    }


    /**
    * @param liveChannelName

    * @param playListName

    * @param expires
    *            URL的过期时间,单位:秒
    * @return rtmp地址

    * */
    public String getSignRtmpUrl(String liveChannelName, String playListName, long expires) {
    try {
    long expiresTime = new Date().getTime() / 1000 + expires;
    GenerateRtmpUriRequest rtmpUriRequest = new GenerateRtmpUriRequest(bucketName, liveChannelName,
    playListName, expiresTime);
    // 生成rtmp签名
    String signedUrl = super.generateRtmpUri(rtmpUriRequest);
    return signedUrl;
    } catch (Exception ex) {
    log.error("Generate rtmp url exception,liveChannel=" + liveChannelName, ex);
    return null;
    }
    }


    private void initOperations(ClientConfiguration config, DefaultCredentialProvider credentialProvider) {
    if (config.isRequestTimeoutEnabled()) {
    this.serviceClientEx = new TimeoutServiceClient(config);
    } else {
    this.serviceClientEx = new DefaultServiceClient(config);
    }
    this.liveChannelOperationEx = new LiveChannelOperationEx(this.serviceClientEx, credentialProvider);
    this.liveChannelOperationEx.setEndpoint(toURI(endPoint));
    }


    private URI toURI(String endpoint) throws IllegalArgumentException {
    if (!endpoint.contains("://")) {
    ClientConfiguration conf = this.serviceClientEx.getClientConfiguration();
    endpoint = conf.getProtocol().toString() + "://" + endpoint;
    }


    try {
    return new URI(endpoint);
    } catch (URISyntaxException e) {
    throw new IllegalArgumentException(e);
    }
    }


    private List<String> getTimeRange(Date beginTime, Date endTime) {
    int begin = (int) (beginTime.getTime() / 1000000);
    int end = (int) (endTime.getTime() / 1000000);
    List<String> lstRange = new ArrayList<String>();
    for (int index = begin; index <= end; index++) {
    lstRange.add(String.valueOf(index));
    }
    return lstRange;
    }

    }

    继承LiveChannelOperation,获取generateVodPlaylist方法结果

    public class LiveChannelOperationEx extends LiveChannelOperation {


    private VodResponseParser vodResponseParser;


    public LiveChannelOperationEx(ServiceClient client, CredentialsProvider credsProvider) {
    super(client, credsProvider);
    vodResponseParser = new VodResponseParser();
    }


    public VodResult generateVodPlaylistEx(GenerateVodPlaylistRequest generateVodPlaylistRequest) throws OSSException,
    ClientException {
    assertParameterNotNull(generateVodPlaylistRequest, "generateVodPlaylistRequest");


    String bucketName = generateVodPlaylistRequest.getBucketName();
    String liveChannelName = generateVodPlaylistRequest.getLiveChannelName();
    String playlistName = generateVodPlaylistRequest.getPlaylistName();
    Long startTime = generateVodPlaylistRequest.getStratTime();
    Long endTime = generateVodPlaylistRequest.getEndTime();


    assertParameterNotNull(bucketName, "bucketName");
    ensureBucketNameValid(bucketName);
    assertParameterNotNull(liveChannelName, "liveChannelName");
    ensureLiveChannelNameValid(liveChannelName);
    assertParameterNotNull(playlistName, "playlistName");
    assertParameterNotNull(startTime, "stratTime");
    assertParameterNotNull(endTime, "endTime");


    Map<String, String> parameters = new HashMap<String, String>();
    parameters.put(RequestParameters.SUBRESOURCE_VOD, null);
    parameters.put(RequestParameters.SUBRESOURCE_START_TIME, startTime.toString());
    parameters.put(RequestParameters.SUBRESOURCE_END_TIME, endTime.toString());


    String key = liveChannelName + "/" + playlistName;
    RequestMessage request = new OSSRequestMessageBuilder(getInnerClient()).setEndpoint(getEndpoint())
    .setMethod(HttpMethod.POST).setBucket(bucketName).setKey(key).setParameters(parameters)
    .setInputStream(new ByteArrayInputStream(new byte[0])).setInputSize(0)
    .setOriginalRequest(generateVodPlaylistRequest).build();


    return doOperation(request, vodResponseParser, bucketName, key);
    }

    }


    更多的关于阿里OSS的访问和操作,请参考:

    https://help.aliyun.com/document_detail/31948.html

    展开全文
  • Hive分桶之BUCKET详解

    千次阅读 2017-02-16 15:04:51
    Bucket 对于每一个表(table)或者分区(partition), Hive可以进一步组织成桶,也就是说桶是更为细粒度的数据范围划分。Hive也是 针对某一列进行桶的组织。Hive采用对列值哈希,然后除以桶的个数求余的方式决定该...
  • Bucket可以理解为存储空间,存储空间是您用于存储对象(Object)的容器,所有的对象都必须隶属于某个存储空间。您可以设置和修改存储空间属性用来控制地域、访问权限、生命周期等,这些属性设置直接作用于该存储空间...
  • qos令牌桶(Token Bucket)算法解析

    万次阅读 2014-03-05 10:55:27
    QoS中的流量监管(Traffic Policing)就是对流量进行控制,通过监督进入网络端口的流量速率,对超出部分的流量进行“惩罚”(这个惩罚可以是丢弃、也可是延迟发送),使... QoS流量监管功能是采用令牌桶(Token-Bucket
  • 七牛云 Bucket是什么?怎么取得

    万次阅读 2017-05-20 17:04:59
    新建存储空间,就是你的空间名 即:Bucket
  • TokenBucket LeakBucketTokenBucketLeakBucket
  • BitBucket介绍以及基础使用

    千次阅读 2017-05-02 14:40:23
    Bitbucket介绍: Bitbucket是一家类似于Github的免费代码托管空间,采用Mercurial和Git作为分布式版本控制系统,总得来说,Bitbucket和Github在代码托管和管理方面都旗鼓相当,Bitbucket甚至在某些方面还要强,只...
  • Bitbucket 删除一个仓库(Repository)

    万次阅读 2014-05-30 16:48:21
    刚在Bitbucket上新建了一个仓库,不过感觉m
  • bucket:按照范围分组官网原生代码:db.artwork.aggregate( [ { $bucket: { groupBy: "$price", boundaries: [ 0, 200, 400 ], default: "Other", output: { "count": { $sum:...
  • 用阿里的OSS进行文件存储时候报出了下面异常:   网上搜了大家的解决方式,大家的解决方式都不太一样,然后我仔细看了看异常内容,对比我自己的配置文件,发现了end_point_extranet 是不同的,我自己用的是 ...
  • 七牛云获取token中的bucket是什么?

    千次阅读 2018-11-22 22:46:12
    做七牛存储API的时候,accessKey 和secretKey 很直观可以在“个人面板”-“密匙管理”中进行配置,那么bucket是什么呢? 引入依赖 &amp;amp;lt;dependency&amp;amp;gt; &amp;amp;lt;groupId&amp;...
  • 关于bitbucket不能注册

    万次阅读 2015-09-12 19:36:56
    BitBucket 是一家源代码托管网站,采用Mercurial和Git作为分布式版本控制系统,同时提供商业计划和免费账户。 想注册他主要是因为想使用免费的git私人仓库。 后来发现无法注册。 后面我仔细琢磨了一下...
  • The specified bucket is not valid

    万次阅读 2016-04-12 18:38:01
    阿里云存储总是提示The specified bucket is not valid
  • Sourcetree和Bitbucket的使用

    千次阅读 2020-03-25 19:20:57
    Sourcetree 和 Bitbucket 的使用 这学期开了 Android 课程,做做笔记。 首先当然是给项目配上版本管理系统,这需要 Git Git是一个免费开源的分布式版本控制系统。 这里收藏了两个教程: 廖雪峰的官方网站- Git ...
  • BitBucket是一家源代码托管网站,采用Mercurial和Git作为分布式版本控制系统,同时提供商业计划和免费账户。免费版本的用户可以有无限的私有Repos,现在你可以将一些不想公开的代码存放在Bitbucket中了。在某些方面...
  • 本文主要来自于萧_瑟BLOG ...目前比较出名的分布式版本控制系统有Bitbucket和Github两家。前者可以创建免费的私有库(用户不超过5人),方便个人或微型项目/组开发项目;后者功能更强大,收费,比较适合公司进行代码版
  • 这个错误的意思是:子用户/临时用户没有访问Object的权限 解决办法:查看自己的配置是否正确,配置修改成功后,问题就解决了
1 2 3 4 5 ... 20
收藏数 102,728
精华内容 41,091
关键字:

bucket