原文链接：http://www.cnblogs.com/juandx/p/4962089.html
python中对文件、文件夹（文件操作函数）的操作需要涉及到os模块和shutil模块。
得到当前工作目录，即当前Python脚本工作的目录路径: os.getcwd()
返回指定目录下的所有文件和目录名:os.listdir()
函数用来删除一个文件:os.remove()
删除多个目录：os.removedirs（r“c：\python”）
检验给出的路径是否是一个文件：os.path.isfile()
检验给出的路径是否是一个目录：os.path.isdir()
判断是否是绝对路径：os.path.isabs()
检验给出的路径是否真地存:os.path.exists()
返回一个路径的目录名和文件名:os.path.split()
eg os.path.split(‘/home/swaroop/byte/code/poem.txt’)
结果：(‘/home/swaroop/byte/code’, ‘poem.txt’)
分离扩展名：os.path.splitext()
获取路径名：os.path.dirname()
获取文件名：os.path.basename()
运行shell命令: os.system()
读取和设置环境变量:os.getenv() 与os.putenv()
给出当前平台使用的行终止符:os.linesep Windows使用’\r\n’，Linux使用’\n’而Mac使用’\r’
指示你正在使用的平台：os.name 对于Windows，它是’nt’，而对于Linux/Unix用户，它是’posix’
重命名：os.rename（old， new）
创建多级目录：os.makedirs（r“c：\python\test”）
创建单个目录：os.mkdir（“test”）
获取文件属性：os.stat（file）
修改文件权限与时间戳：os.chmod（file）
终止当前进程：os.exit（）
获取文件大小：os.path.getsize（filename）
文件操作：
os.mknod(“test.txt”) 创建空文件
fp = open(“test.txt”,w) 直接打开一个文件，如果文件不存在则创建文件
关于open 模式：
w 以写方式打开，
a 以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+ 以读写模式打开
w+ 以读写模式打开 (参见 w )
a+ 以读写模式打开 (参见 a )
rb 以二进制读模式打开
wb 以二进制写模式打开 (参见 w )
ab 以二进制追加模式打开 (参见 a )
rb+ 以二进制读写模式打开 (参见 r+ )
wb+ 以二进制读写模式打开 (参见 w+ )
ab+ 以二进制读写模式打开 (参见 a+ )
fp.read([size]) #size为读取的长度，以byte为单位
fp.readline([size]) #读一行，如果定义了size，有可能返回的只是一行的一部分
fp.readlines([size]) #把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长，也就是说可能只读到文件的一部分。
fp.write(str) #把str写到文件中，write()并不会在str后加上一个换行符
fp.writelines(seq) #把seq的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入，不会在每行后面加上任何东西。
fp.close() #关闭文件。python会在一个文件不用后自动关闭文件，不过这一功能没有保证，最好还是养成自己关闭的习惯。 如果一个文件在关闭后还对其进行操作会产生ValueError
fp.flush() #把缓冲区的内容写入硬盘
fp.fileno() #返回一个长整型的”文件标签“
fp.isatty() #文件是否是一个终端设备文件（unix系统中的）
fp.tell() #返回文件操作标记的当前位置，以文件的开头为原点
fp.next() #返回下一行，并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时，就是调用next()函数来实现遍历的。
fp.seek(offset[,whence]) #将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的，一般为正数。但如果提供了whence参数就不一定了，whence可以为0表示从头开始计算，1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意，如果文件以a或a+的模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾。
fp.truncate([size]) #把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大，依据系统的不同可能是不改变文件，也可能是用0把文件补到相应的大小，也可能是以一些随机的内容加上去。
目录操作：
os.mkdir(“file”) 创建目录
复制文件：
shutil.copyfile(“oldfile”,”newfile”) oldfile和newfile都只能是文件
shutil.copy(“oldfile”,”newfile”) oldfile只能是文件夹，newfile可以是文件，也可以是目标目录
复制文件夹：
shutil.copytree(“olddir”,”newdir”) olddir和newdir都只能是目录，且newdir必须不存在
重命名文件（目录）
os.rename(“oldname”,”newname”) 文件或目录都是使用这条命令
移动文件（目录）
shutil.move(“oldpos”,”newpos”)
删除文件
os.remove(“file”)
删除目录
os.rmdir(“dir”)只能删除空目录
shutil.rmtree(“dir”) 空目录、有内容的目录都可以删
转换目录
os.chdir(“path”) 换路径
Python读写文件
1.open
使用open打开文件后一定要记得调用文件对象的close()方法。比如可以用try/finally语句来确保最后能关闭文件。
file_object = open(‘thefile.txt’)
try:
all_the_text = file_object.read( )
finally:
file_object.close( )
注：不能把open语句放在try块里，因为当打开文件出现异常时，文件对象file_object无法执行close()方法。
2.读文件
读文本文件
input = open('data', 'r')
#第二个参数默认为r
input = open('data')
1
2
3
读二进制文件
input = open('data', 'rb')
1
读取所有内容
file_object = open('thefile.txt')
try:
all_the_text = file_object.read( )
finally:
file_object.close( )
1
2
3
4
5
读固定字节
file_object = open('abinfile', 'rb')
try:
while True:
chunk = file_object.read(100)
if not chunk:
break
do_something_with(chunk)
finally:
file_object.close( )
1
2
3
4
5
6
7
8
9
读每行
list_of_all_the_lines = file_object.readlines( )
1
如果文件是文本文件，还可以直接遍历文件对象获取每行：
for line in file_object:
process line
1
2
3.写文件
写文本文件
output = open('data', 'w')
1
写二进制文件
output = open('data', 'wb')
1
追加写文件
output = open('data', 'w+')
1
写数据
file_object = open('thefile.txt', 'w')
file_object.write(all_the_text)
file_object.close( )
1
2
3
写入多行
file_object.writelines(list_of_text_strings)
1
注意，调用writelines写入多行在性能上会比使用write一次性写入要高。
在处理日志文件的时候，常常会遇到这样的情况：日志文件巨大，不可能一次性把整个文件读入到内存中进行处理，例如需要在一台物理内存为 2GB 的机器上处理一个 2GB 的日志文件，我们可能希望每次只处理其中 200MB 的内容。
在 Python 中，内置的 File 对象直接提供了一个 readlines(sizehint) 函数来完成这样的事情。以下面的代码为例：
file = open('test.log', 'r')sizehint = 209715200 # 200Mposition = 0lines = file.readlines(sizehint)while not file.tell() - position < 0: position = file.tell() lines = file.readlines(sizehint)
1
每次调用 readlines(sizehint) 函数，会返回大约 200MB 的数据，而且所返回的必然都是完整的行数据，大多数情况下，返回的数据的字节数会稍微比 sizehint 指定的值大一点（除最后一次调用 readlines(sizehint) 函数的时候）。通常情况下，Python 会自动将用户指定的 sizehint 的值调整成内部缓存大小的整数倍。
file在python是一个特殊的类型，它用于在python程序中对外部的文件进行操作。在python中一切都是对象，file也不例外，file有file的方法和属性。下面先来看如何创建一个file对象：
file(name[, mode[, buffering]])
1
file()函数用于创建一个file对象，它有一个别名叫open()，可能更形象一些，它们是内置函数。来看看它的参数。它参数都是以字符串的形式传递的。name是文件的名字。
mode是打开的模式，可选的值为r w a U，分别代表读（默认） 写 添加支持各种换行符的模式。用w或a模式打开文件的话，如果文件不存在，那么就自动创建。此外，用w模式打开一个已经存在的文件时，原有文件的内容会被清空，因为一开始文件的操作的标记是在文件的开头的，这时候进行写操作，无疑会把原有的内容给抹掉。由于历史的原因，换行符在不同的系统中有不同模式，比如在 unix中是一个\n，而在windows中是‘\r\n’，用U模式打开文件，就是支持所有的换行模式，也就说‘\r’ ‘\n’ ‘\r\n’都可表示换行，会有一个tuple用来存贮这个文件中用到过的换行符。不过，虽说换行有多种模式，读到python中统一用\n代替。在模式字符的后面，还可以加上+ b t这两种标识，分别表示可以对文件同时进行读写操作和用二进制模式、文本模式（默认）打开文件。
buffering如果为0表示不进行缓冲;如果为1表示进行“行缓冲“;如果是一个大于1的数表示缓冲区的大小，应该是以字节为单位的。
file对象有自己的属性和方法。先来看看file的属性。
closed #标记文件是否已经关闭，由close()改写
encoding #文件编码
mode #打开模式
name #文件名
newlines #文件中用到的换行模式，是一个tuple
softspace #boolean型，一般为0，据说用于print
1
2
3
4
5
6
file的读写方法：
F.read([size]) #size为读取的长度，以byte为单位
F.readline([size])
#读一行，如果定义了size，有可能返回的只是一行的一部分
F.readlines([size])
#把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长，也就是说可能只读到文件的一部分。
F.write(str)
#把str写到文件中，write()并不会在str后加上一个换行符
F.writelines(seq)
#把seq的内容全部写到文件中。这个函数也只是忠实地写入，不会在每行后面加上任何东西。
file的其他方法：
F.close()
#关闭文件。python会在一个文件不用后自动关闭文件，不过这一功能没有保证，最好还是养成自己关闭的习惯。如果一个文件在关闭后还对其进行操作会产生ValueError
F.flush()
#把缓冲区的内容写入硬盘
F.fileno()
#返回一个长整型的”文件标签“
F.isatty()
#文件是否是一个终端设备文件（unix系统中的）
F.tell()
#返回文件操作标记的当前位置，以文件的开头为原点
F.next()
#返回下一行，并将文件操作标记位移到下一行。把一个file用于for ... in file这样的语句时，就是调用next()函数来实现遍历的。
F.seek(offset[,whence])
#将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的，一般为正数。但如果提供了whence参数就不一定了，whence可以为0表示从头开始计算，1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意，如果文件以a或a+的模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾。
F.truncate([size])
#把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大，依据系统的不同可能是不改变文件，也可能是用0把文件补到相应的大小，也可能是以一些随机的内容加上去。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
http://www.cnblogs.com/allenblogs/archive/2010/09/13/1824842.html
http://www.cnblogs.com/rollenholt/archive/2012/04/23/2466179.html
首先 dfs.replication这个参数是个client参数，即node level参数。需要在每台datanode上设置。
其实默认为3个副本已经够用了，设置太多也没什么用。
一个文件，上传到hdfs上时指定的是几个副本就是几个。以后你修改了副本数，对已经上传了的文件也不会起作用。可以再上传文件的同时指定创建的副本数
Hadoop dfs -D dfs.replication=1 -put 70M logs/2
可以通过命令来更改已经上传的文件的副本数：
hadoop fs -setrep -R 3 /
查看当前hdfs的副本数
hadoop fsck -locations
FSCK started by hadoop from /172.18.6.112 for path / at Thu Oct 27 13:24:25 CST 2011
....................Status: HEALTHY
Total size: 4834251860 B
Total dirs: 21
Total files: 20
Total blocks (validated): 82 (avg. block size 58954290 B)
Minimally replicated blocks: 82 (100.0 %)
Over-replicated blocks: 0 (0.0 %)
Under-replicated blocks: 0 (0.0 %)
Mis-replicated blocks: 0 (0.0 %)
Default replication factor: 3
Average block replication: 3.0
Corrupt blocks: 0
Missing replicas: 0 (0.0 %)
Number of data-nodes: 3
Number of racks: 1
FSCK ended at Thu Oct 27 13:24:25 CST 2011 in 10 milliseconds
The filesystem under path '/' is HEALTHY
某个文件的副本数，可以通过ls中的文件描述符看到
hadoop dfs -ls
-rw-r--r-- 3 hadoop supergroup 153748148 2011-10-27 16:11 /user/hadoop/logs/201108/impression_witspixel2011080100.thin.log.gz
如果你只有3个datanode，但是你却指定副本数为4，是不会生效的，因为每个datanode上只能存放一个副本。
参考：http://blog.csdn.net/lskyne/article/details/8898666
转自：https://www.cnblogs.com/shabbylee/p/6792555.html
由于历史原因，Python有两个大的版本分支，Python2和Python3，又由于一些库只支持某个版本分支，所以需要在电脑上同时安装Python2和Python3，因此如何让两个版本的Python兼容，如何让脚本在对应的Python版本上运行，这个是值得总结的。
对于Ubuntu 16.04 LTS版本来说，Python2（2.7.12）和Python3（3.5.2）默认同时安装，默认的python版本是2.7.12。
当然你也可以用python2来调用。
如果想调用python3，就用python3.
对于Windows，就有点复杂了。因为不论python2还是python3，python可执行文件都叫python.exe，在cmd下输入python得到的版本号取决于环境变量里哪个版本的python路径更靠前，毕竟windows是按照顺序查找的。比如环境变量里的顺序是这样的：
那么cmd下的python版本就是2.7.12。
反之，则是python3的版本号。
这就带来一个问题了，如果你想用python2运行一个脚本，一会你又想用python3运行另一个脚本，你怎么做？来回改环境变量显然很麻烦。
网上很多办法比较简单粗暴，把两个python.exe改名啊，一个改成python2.exe，一个改成python3.exe。这样做固然可以，但修改可执行文件的方式，毕竟不是很好的方法。
我仔细查找了一些python技术文档，发现另外一个我觉得比较好的解决办法。
借用py的一个参数来调用不同版本的Python。py -2调用python2，py -3调用的是python3.
当python脚本需要python2运行时，只需在脚本前加上，然后运行py xxx.py即可。
#! python2
当python脚本需要python3运行时，只需在脚本前加上，，然后运行py xxx.py即可。
#! python3
就这么简单。
同时，这也完美解决了在pip在python2和python3共存的环境下报错，提示Fatal error in launcher: Unable to create process using '"'的问题。
当需要python2的pip时，只需
py -2 -m pip install xxx
当需要python3的pip时，只需
py -3 -m pip install xxx
python2和python3的pip package就这样可以完美分开了。
Sentry权限控制通过Beeline（Hiveserver2 SQL 命令行接口）输入Grant 和 Revoke语句来配置。语法跟现在的一些主流的关系数据库很相似。需要注意的是：当sentry服务启用后，我们必须使用beeline接口来执行hive查询，Hive Cli并不支持sentry。
CREATE ROLE Statement
CREATE ROLE语句创建一个可以被赋权的角色。权限可以赋给角色，然后再分配给各个用户。一个用户被分配到角色后可以执行该角色的权限。
只有拥有管理员的角色可以create/drop角色。默认情况下，hive、impala和hue用户拥有管理员角色。
CREATE ROLE [role_name];
DROP ROLE Statement
DROP ROLE语句可以用来从数据库中移除一个角色。一旦移除，之前分配给所有用户的该角色将会取消。之前已经执行的语句不会受到影响。但是，因为hive在执行每条查询语句之前会检查用户的权限，处于登录活跃状态的用户会话会受到影响。
DROP ROLE [role_name];
GRANT ROLE Statement
GRANT ROLE语句可以用来给组授予角色。只有sentry的管理员用户才能执行该操作。
GRANT ROLE role_name [, role_name]
TO GROUP （groupName） [,GROUP （groupName）]
REVOKE ROLE Statement
REVOKE ROLE语句可以用来从组移除角色。只有sentry的管理员用户才能执行该操作。
REVOKE ROLE role_name [, role_name]
FROM GROUP （groupName) [,GROUP (groupName)]
GRANT (PRIVILEGE) Statement
授予一个对象的权限给一个角色，该用户必须为sentry的管理员用户。
GRANT
(PRIVILEGE) [, (PRIVILEGE) ]
ON (OBJECT) (object_name)
TO ROLE (roleName) [,ROLE (roleName)]
REVOKE （PRIVILEGE） Statement
因为只有认证的管理员用户可以创建角色，从而只有管理员用户可以取消一个组的权限。
REVOKE
(PRIVILEGE) [, (PRIVILEGE) ]
ON (OBJECT) (object_name)
FROM ROLE (roleName) [,ROLE (roleName)]
GRANT (PRIVILEGE) ... WITH GRANT OPTION
在cdh5.2中，你可以委托给其他角色来授予和解除权限。比如，一个角色被授予了WITH GRANT OPTION的权限可以GRANT/REVOKE同样的权限给其他角色。因此，如果一个角色有一个库的所有权限并且设置了 WITH GRANT OPTION，该角色分配的用户可以对该数据库和其中的表执行GRANT/REVOKE语句。
GRANT
（PRIVILEGE）
ON （OBJECT） （object_name）
TO ROLE （roleName）
WITH GRANT OPTION
只有一个带GRANT选项的特殊权限的角色或者它的父级权限可以从其他角色解除这种权限。一旦下面的语句执行，所有跟其相关的grant权限将会被解除。
REVOKE
（RIVILEGE）
ON （BJECT） （bject_name）
FROM ROLE （roleName）
Hive目前不支持解除之前赋予一个角色 WITH GRANT OPTION 的权限。要想移除WITH GRANT OPTION、解除权限，可以重新去除 WITH GRANT OPTION这个标记来再次附权。
SET ROLE Statement
SET ROLE语句可以给当前会话选择一个角色使之生效。一个用户只能启用分配给他的角色。任何不存在的角色和当前用户不能使用的角色是不能生效的。如果没有使用任何角色，用户将会使用任何一个属于他的角色的权限。
选择一个角色使用：
To enable a specific role:
使用所有的角色：
To enable a specific role:
关闭所有角色
SET ROLE NONE;
SHOW Statement
显示当前用户拥有库、表、列相关权限的数据库：
SHOW DATABASES;
显示当前用户拥有表、列相关权限的表；
SHOW TABLES;
显示当前用户拥有SELECT权限的列：
SHOW COLUMNS (FROM|IN) table_name [(FROM|IN) db_name];
显示当前系统中所有的角色（只有管理员用户可以执行）：
SHOW ROLES;
显示当前影响当前会话的角色：
SHOW CURRENT ROLES;
显示指定组的被分配到的所有角色（只有管理员用户和指定组内的用户可以执行）
SHOW ROLE GRANT GROUP (groupName);
SHOW语句可以用来显示一个角色被授予的权限或者显示角色的一个特定对象的所有权限。
显示指定角色的所有被赋予的权限。（只有管理员用户和指定角色分配到的用户可以执行）。下面的语句也会显示任何列级的权限。
SHOW GRANT ROLE (roleName);
显示指定对象的一个角色的所有被赋予的权限（只有管理员用户和指定角色分配到的用户可以执行）。下面的语句也会显示任何列级的权限。
SHOW GRANT ROLE (roleName) on (OBJECT) (objectName);
----------------------------我也是有底线的-----------------------------
摘要: Python 里面的编码和解码也就是 unicode 和 str 这两种形式的相互转化。编码是 unicode -> str，相反的，解码就是 str -> unicode。剩下的问题就是确定何时需要进行编码或者解码了.关于文件开头的"编码指示"，也就是 # -*- codin...
摘要: 我们每次执行hive的hql时，shell里都会提示一段话：[python] view plaincopy... Number of reduce tasks not specified. Estimated from input data size: 50...
摘要: spark 累加历史主要用到了窗口函数，而进行全部统计，则需要用到rollup函数
1 应用场景：
1、我们需要统计用户的总使用时长（累加历史）
2、前台展现页面需要对多个维度进行查询，如：产品、地区等等
3、需要展现的表格头如： 产品、2015-04、2015-05、2015-06
2 原始数据：
product_code |event_date |dur...
摘要: Spark1.4发布，支持了窗口分析函数(window functions)。在离线平台中，90%以上的离线分析任务都是使用Hive实现，其中必然会使用很多窗口分析函数，如果SparkSQL支持窗口分析函数，
那么对于后面Hive向SparkSQL中的迁移的工作量会大大降低，使用方式如下：
1、初始化数据
创建表
[sql] view plain cop...
1.in 不支持子查询 eg. select * from src where key in(select key from test);
支持查询个数 eg. select * from src where key in(1,2,3,4,5);
in 40000个 耗时25.766秒
in 80000个 耗时78.827秒
2.union all/union
不支持顶层的union all eg. select key from src UNION ALL select key from test;
支持select * from (select key from src union all select key from test)aa;
不支持 union
支持select distinct key from (select key from src union all select key from test)aa;
3.intersect 不支持
4.minus 不支持
5.except 不支持
6.inner join/join/left outer join/right outer join/full outer join/left semi join 都支持
left outer join/right outer join/full outer join 中间必须有outer
join是最简单的关联操作，两边关联只取交集;
left outer join是以左表驱动，右表不存在的key均赋值为null；
right outer join是以右表驱动，左表不存在的key均赋值为null；
full outer join全表关联，将两表完整的进行笛卡尔积操作，左右表均可赋值为null;
left semi join最主要的使用场景就是解决exist in;
Hive不支持where子句中的子查询，SQL常用的exist in子句在Hive中是不支持的
不支持子查询 eg. select * from src aa where aa.key in(select bb.key from test bb);
可用以下两种方式替换：
select * from src aa left outer join test bb on aa.key=bb.key where bb.key <> null;
select * from src aa left semi join test bb on aa.key=bb.key;
大多数情况下 JOIN ON 和 left semi on 是对等的
A,B两表连接，如果B表存在重复数据
当使用JOIN ON的时候，A,B表会关联出两条记录，应为ON上的条件符合；
而是用LEFT SEMI JOIN 当A表中的记录，在B表上产生符合条件之后就返回，不会再继续查找B表记录了，
所以如果B表有重复，也不会产生重复的多条记录。
left outer join 支持子查询 eg. select aa.* from src aa left outer join (select * from test111)bb on aa.key=bb.a;
7. hive四中数据导入方式
1）从本地文件系统中导入数据到Hive表
create table wyp(id int,name string) ROW FORMAT delimited fields terminated by '\t' STORED AS TEXTFILE;
load data local inpath 'wyp.txt' into table wyp;
2)从HDFS上导入数据到Hive表
[wyp@master /home/q/hadoop-2.2.0]$ bin/hadoop fs -cat /home/wyp/add.txt
hive> load data inpath '/home/wyp/add.txt' into table wyp;
3)从别的表中查询出相应的数据并导入到Hive表中
hive> create table test(
> id int, name string
> ,tel string)
> partitioned by
> (age int)
> ROW FORMAT DELIMITED
> FIELDS TERMINATED BY '\t'
> STORED AS TEXTFILE;
注：test表里面用age作为了分区字段，分区：在Hive中，表的每一个分区对应表下的相应目录，所有分区的数据都是存储在对应的目录中。
比如wyp表有dt和city两个分区，则对应dt=20131218city=BJ对应表的目录为/user/hive/warehouse/dt=20131218/city=BJ，
所有属于这个分区的数据都存放在这个目录中。
hive> insert into table test
> partition (age='25')
> select id, name, tel
> from wyp;
也可以在select语句里面通过使用分区值来动态指明分区：
hive> set hive.exec.dynamic.partition.mode=nonstrict;
hive> insert into table test
> partition (age)
> select id, name,
> tel, age
> from wyp;
Hive也支持insert overwrite方式来插入数据
hive> insert overwrite table test
> PARTITION (age)
> select id, name, tel, age
> from wyp;
Hive还支持多表插入
hive> from wyp
> insert into table test
> partition(age)
> select id, name, tel, age
> insert into table test3
> select id, name
> where age>25;
4)在创建表的时候通过从别的表中查询出相应的记录并插入到所创建的表中
hive> create table test4
> as
> select id, name, tel
> from wyp;
8.查看建表语句
hive> show create table test3;
9.表重命名
hive> ALTER TABLE events RENAME TO 3koobecaf;
10.表增加列
hive> ALTER TABLE pokes ADD COLUMNS (new_col INT);
11.添加一列并增加列字段注释
hive> ALTER TABLE invites ADD COLUMNS (new_col2 INT COMMENT 'a comment');
12.删除表
hive> DROP TABLE pokes;
13.top n
hive> select * from test order by key limit 10;
14.创建数据库
Create Database baseball;
14.alter table tablename change oldColumn newColumn column_type 修改列的名称和类型
alter table yangsy CHANGE product_no phone_no string
15.导入.sql文件中的sql
spark-sql --driver-class-path /home/hadoop/hive/lib/mysql-connector-java-5.1.30-bin.jar -f testsql.sql
insert into table CI_CUSER_20141117154351522 select mainResult.PRODUCT_NO,dw_coclbl_m02_3848.L1_01_02_01,dw_coclbl_d01_3845.L2_01_01_04 from (select PRODUCT_NO from CI_CUSER_20141114203632267) mainResult left join DW_COCLBL_M02_201407 dw_coclbl_m02_3848 on mainResult.PRODUCT_NO = dw_coclbl_m02_3848.PRODUCT_NO left join DW_COCLBL_D01_20140515 dw_coclbl_d01_3845 on dw_coclbl_m02_3848.PRODUCT_NO = dw_coclbl_d01_3845.PRODUCT_NO
insert into CI_CUSER_20141117142123638 ( PRODUCT_NO,ATTR_COL_0000,ATTR_COL_0001) select mainResult.PRODUCT_NO,dw_coclbl_m02_3848.L1_01_02_01,dw_coclbl_m02_3848.L1_01_03_01 from (select PRODUCT_NO from CI_CUSER_20141114203632267) mainResult left join DW_COCLBL_M02_201407 dw_coclbl_m02_3848 on mainResult.PRODUCT_NO = dw_coclbl_m02_3848.PRODUCT_NO
CREATE TABLE ci_cuser_yymmddhhmisstttttt_tmp(product_no string) row format serde 'com.bizo.hive.serde.csv.CSVSerde' ;
LOAD DATA LOCAL INPATH '/home/ocdc/coc/yuli/test123.csv' OVERWRITE INTO TABLE test_yuli2;
创建支持CSV格式的testfile文件
CREATE TABLE test_yuli7 row format serde 'com.bizo.hive.serde.csv.CSVSerde' as select * from CI_CUSER_20150310162729786;
不依赖CSVSerde的jar包创建逗号分隔的表
"create table " +listName+ " ROW FORMAT DELIMITED FIELDS TERMINATED BY ','" +
" as select * from " + listName1;
create table aaaa ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' LINES TERMINATED BY '\n' STORED AS TEXTFILE as select * from
ThriftServer 开启FAIR模式
SparkSQL Thrift Server 开启FAIR调度方式:
1. 修改$SPARK_HOME/conf/spark-defaults.conf,新增
2. spark.scheduler.mode FAIR
3. spark.scheduler.allocation.file /Users/tianyi/github/community/apache-spark/conf/fair-scheduler.xml
4. 修改$SPARK_HOME/conf/fair-scheduler.xml(或新增该文件), 编辑如下格式内容
5. <?xml version="1.0"?>
6. <allocations>
7. <pool name="production">
8. <schedulingMode>FAIR</schedulingMode>
9. <!-- weight表示两个队列在minShare相同的情况下,可以使用资源的比例 -->
10. <weight>1</weight>
11. <!-- minShare表示优先保证的资源数 -->
12. <minShare>2</minShare>
13. </pool>
14. <pool name="test">
15. <schedulingMode>FIFO</schedulingMode>
16. <weight>2</weight>
17. <minShare>3</minShare>
18. </pool>
19. </allocations>
20. 重启Thrift Server
21. 执行SQL前,执行
22. set spark.sql.thriftserver.scheduler.pool=指定的队列名
等操作完了 create table yangsy555 like CI_CUSER_YYMMDDHHMISSTTTTTT 然后insert into yangsy555 select * from yangsy555
创建一个自增序列表，使用row_number() over()为表增加序列号 以供分页查询
create table yagnsytest2 as SELECT ROW_NUMBER() OVER() as id,* from yangsytest;
Sparksql的解析与Hiveql的解析的执行流程:
如果用传统SCP远程拷贝，速度是比较慢的。现在采用lz4压缩传输。LZ4是一个非常快的无损压缩算法，压缩速度在单核300MB/S，可扩展支持多核CPU。它还具有一个非常快速的解码器，速度单核可达到和超越1GB/S。通常能够达到多核系统上的RAM速度限制。
你PV 全命为Pipe Viewer，利用它我们可以查看到命令执行的进度。
下面介绍下lz4和pv的安装，下载软件：
下载pv-1.1.4.tar.gz wget http://sourceforge.jp/projects/sfnet_pipeviewer/downloads/pipeviewer/1.1.4/pv-1.1.4.tar.bz2/
下lz4的包难一些，可能要FQ：https://dl.dropboxusercontent.com/u/59565338/LZ4/lz4-r108.tar.gz
安装灰常简单：
pv安装：
[root ~]$ tar jxvf pv-1.1.4.tar.bz2
[root ~]$ cd pv-1.1.4
[root pv-1.1.4]$ ./configure && make && make install
lz4安装：
[root ~]$ tar zxvf lz4-r108.tar.gz
[root ~]$ cd lz4-r108
[root lz4-r108]$ make && make install
用法：（-c 后指定要传输的文件，ssh -p 是指定端口，后面的ip是目标主机的ip, -xC指定传到目标主机下的那个目录下，别的不用修改）：
tar -c mysql-slave-3307 |pv|lz4 -B4|ssh -p10022 -c arcfour128 -o"MACs umac-64@openssh.com" 192.168.100.234 "lz4 -d |tar -xC /data"
下面是我线上传一个从库的效果：
看到了吧，25.7G 只需要接近3分钟，这样远比scp速度快上了好几倍，直接scp拷贝离散文件，很消耗IO，而使用LZ4快速压缩，对性能影响不大，传输速度快
PS：下次补充同机房不同网段的传输效果及跨机房的传输效果^0^
作者：陆炫志
出处：xuanzhi的博客 http://www.cnblogs.com/xuanzhi201111
您的支持是对博主最大的鼓励，感谢您的认真阅读。本文版权归作者所有，欢迎转载，但请保留该声明。
王 腾腾 和 邵 兵
2015 年 11 月 26 日发布
WeiboGoogle+用电子邮件发送本页面
Comments 1
引子
随着云时代的来临，大数据（Big data）也获得了越来越多的关注。著云台的分析师团队认为，大数据（Big data）通常用来形容一个公司创造的大量非结构化和半结构化数据，这些数据在下载到关系型数据库用于分析时会花费过多时间和金钱。大数据分析常和云计算联系到一起，因为实时的大型数据集分析需要像 MapReduce 一样的框架来向数十、数百或甚至数千的电脑分配工作。
“大数据”在互联网行业指的是这样一种现象：互联网公司在日常运营中生成、累积的用户网络行为数据。这些数据的规模是如此庞大，以至于不能用 G 或 T 来衡量。所以如何高效的处理分析大数据的问题摆在了面前。对于大数据的处理优化方式有很多种，本文中主要介绍在使用 Hadoop 平台中对数据进行压缩处理来提高数据处理效率。
压缩简介
Hadoop 作为一个较通用的海量数据处理平台，每次运算都会需要处理大量数据，我们会在 Hadoop 系统中对数据进行压缩处理来优化磁盘使用率，提高数据在磁盘和网络中的传输速度，从而提高系统处理数据的效率。在使用压缩方式方面，主要考虑压缩速度和压缩文件的可分割性。综合所述，使用压缩的优点如下：
1. 节省数据占用的磁盘空间；
2. 加快数据在磁盘和网络中的传输速度，从而提高系统的处理速度。
压缩格式
Hadoop 对于压缩格式的是自动识别。如果我们压缩的文件有相应压缩格式的扩展名（比如 lzo，gz，bzip2 等）。Hadoop 会根据压缩格式的扩展名自动选择相对应的解码器来解压数据，此过程完全是 Hadoop 自动处理，我们只需要确保输入的压缩文件有扩展名。
Hadoop 对每个压缩格式的支持, 详细见下表：
表 1. 压缩格式
压缩格式 工具 算法 扩展名 多文件 可分割性
DEFLATE 无 DEFLATE .deflate 不 不
GZIP gzip DEFLATE .gzp 不 不
ZIP zip DEFLATE .zip 是 是，在文件范围内
BZIP2 bzip2 BZIP2 .bz2 不 是
LZO lzop LZO .lzo 不 是
如果压缩的文件没有扩展名，则需要在执行 MapReduce 任务的时候指定输入格式。
1
2
3
4
5
hadoop jar /usr/home/hadoop/hadoop-0.20.2/contrib/streaming/
hadoop-streaming-0.20.2-CD H3B4.jar -file /usr/home/hadoop/hello/mapper.py -mapper /
usr/home/hadoop/hello/mapper.py -file /usr/home/hadoop/hello/
reducer.py -reducer /usr/home/hadoop/hello/reducer.py -input lzotest -output result4 -
jobconf mapred.reduce.tasks=1*-inputformatorg.apache.hadoop.mapred.LzoTextInputFormat*
性能对比
Hadoop 下各种压缩算法的压缩比，压缩时间，解压时间见下表:
表 2. 性能对比
压缩算法 原始文件大小 压缩文件大小 压缩速度 解压速度
gzip 8.3GB 1.8GB 17.5MB/s 58MB/s
bzip2 8.3GB 1.1GB 2.4MB/s 9.5MB/s
LZO-bset 8.3GB 2GB 4MB/s 60.6MB/s
LZO 8.3GB 2.9GB 49.3MB/s 74.6MB/s
因此我们可以得出：
1) Bzip2 压缩效果明显是最好的，但是 bzip2 压缩速度慢，可分割。
2) Gzip 压缩效果不如 Bzip2，但是压缩解压速度快，不支持分割。
3) LZO 压缩效果不如 Bzip2 和 Gzip，但是压缩解压速度最快！并且支持分割！
这里提一下，文件的可分割性在 Hadoop 中是很非常重要的，它会影响到在执行作业时 Map 启动的个数，从而会影响到作业的执行效率！
所有的压缩算法都显示出一种时间空间的权衡，更快的压缩和解压速度通常会耗费更多的空间。在选择使用哪种压缩格式时，我们应该根据自身的业务需求来选择。
下图是在本地压缩与通过流将压缩结果上传到 BI 的时间对比。
图 1. 时间对比
图 1. 时间对比
使用方式
MapReduce 可以在三个阶段中使用压缩。
1. 输入压缩文件。如果输入的文件是压缩过的，那么在被 MapReduce 读取时，它们会被自动解压。
2.MapReduce 作业中，对 Map 输出的中间结果集压缩。实现方式如下：
1）可以在 core-site.xml 文件中配置，代码如下
图 2. core-site.xml 代码示例
图 2. core-site.xml 代码示例
2）使用 Java 代码指定
1
2
conf.setCompressMapOut(true);
conf.setMapOutputCompressorClass(GzipCode.class);
最后一行代码指定 Map 输出结果的编码器。
3.MapReduce 作业中，对 Reduce 输出的最终结果集压。实现方式如下：
1）可以在 core-site.xml 文件中配置，代码如下
图 3. core-site.xml 代码示例
图 3. core-site.xml 代码示例
2）使用 Java 代码指定
1
2
conf.setBoolean(“mapred.output.compress”,true);
conf.setClass(“mapred.output.compression.codec”,GzipCode.class,CompressionCodec.class);
最后一行同样指定 Reduce 输出结果的编码器。
压缩框架
我们前面已经提到过关于压缩的使用方式，其中第一种就是将压缩文件直接作为入口参数交给 MapReduce 处理，MapReduce 会自动根据压缩文件的扩展名来自动选择合适解压器处理数据。那么到底是怎么实现的呢？如下图所示：
图 4. 压缩实现情形
图 4. 压缩实现情形
我们在配置 Job 作业的时候，会设置数据输入的格式化方式，使用 conf.setInputFormat() 方法，这里的入口参数是 TextInputFormat.class。
TextInputFormat.class 继承于 InputFormat.class，主要用于对数据进行两方面的预处理。一是对输入数据进行切分，生成一组 split，一个 split 会分发给一个 mapper 进行处理；二是针对每个 split，再创建一个 RecordReader 读取 split 内的数据，并按照
的形式组织成一条 record 传给 map 函数进行处理。此类在对数据进行切分之前，会首先初始化压缩解压工程类 CompressionCodeFactory.class，通过工厂获取实例化的编码解码器 CompressionCodec 后对数据处理操作。
下面我们来详细的看一下从压缩工厂获取编码解码器的过程。
压缩解压工厂类 CompressionCodecFactory
压缩解压工厂类 CompressionCodeFactory.class 主要功能就是负责根据不同的文件扩展名来自动获取相对应的压缩解压器 CompressionCodec.class，是整个压缩框架的核心控制器。我们来看下 CompressionCodeFactory.class 中的几个重要方法：
1. 初始化方法
图 5. 代码示例
图 5. 代码示例
① getCodeClasses(conf) 负责获取关于编码解码器 CompressionCodec.class 的配置信息。下面将会详细讲解。
② 默认添加两种编码解码器。当 getCodeClass(conf) 方法没有读取到相关的编码解码器 CompressionCodec.class 的配置信息时，系统会默认添加两种编码解码器 CompressionCodec.class，分别是 GzipCode.class 和 DefaultCode.class。
③ addCode(code) 此方法用于将编码解码器 CompressionCodec.class 添加到系统缓存中。下面将会详细讲解。
2. getCodeClasses(conf)
图 6. 代码示例
图 6. 代码示例
① 这里我们可以看，系统读取关于编码解码器 CompressionCodec.class 的配置信息在 core-site.xml 中 io.compression.codes 下。我们看下这段配置文件，如下图所示：
图 7. 代码示例
图 7. 代码示例
Value 标签中是每个编码解码 CompressionCodec.class 的完整路径，中间用逗号分隔。我们只需要将自己需要使用到的编码解码配置到此属性中，系统就会自动加载到缓存中。
除了上述的这种方式以外，Hadoop 为我们提供了另一种加载方式：代码加载。同样最终将信息配置在 io.compression.codes 属性中，代码如下：
1
2
conf.set("io.compression.codecs","org.apache.hadoop.io.compress.DefaultCodec,
org.apache.hadoop.io.compress.GzipCodec,com.hadoop.compression.lzo.LzopCodec");)
3. addCode(code) 方法添加编码解码器
图 8. 代码示例
图 8. 代码示例
addCodec(codec) 方法入口参数是个编码解码器 CompressionCodec.class，这里我们会首先接触到它的一个方法。
① codec.getDefaultExtension() 方法看方法名的字面意思我们就可以知道，此方法用于获取此编码解码所对应文件的扩展名，比如，文件名是 xxxx.gz2，那么这个方法的返回值就是“.bz2”，我们来看下 org.apache.hadoop.io.compress.BZip2Codec 此方法的实现代码：
图 9. 代码示例
图 9. 代码示例
② Codecs 是一个 SortedMap 的示例。这里有个很有意思的地方，它将 Key 值，也就是通过 codec.getDefaultExtension() 方法获取到的文件扩展名进行了翻转，举个例子，比如文件名扩展名“.bz2”，将文件名翻转之后就变成了“2zb.”。
系统加载完所有的编码解码器后，我们可以得到这样一个有序映射表，如下：
图 10. 代码示例
图 10. 代码示例
现在编码解码器都有了，我们怎么得到对应的编码解码器呢？看下面这个方法。
4. getCodec() 方法
此方法用于获取文件所对应的的编码解码器 CompressionCodec.class。
图 11. 代码示例
图 11. 代码示例
getCodec(Path) 方法的输入参数是 Path 对象，保存着文件路径。
① 将文件名翻转。如 xxxx.bz2 翻转成 2zb.xxxx。
② 获取 codecs 集合中最接近 2zb.xxxx 的值。此方法有返回值同样是个 SortMap 对象。
在这里对返回的 SortMap 对象进行第二次筛选。
编码解码器 CompressionCodec
刚刚在介绍压缩解压工程类 CompressionCodeFactory.class 的时候，我们多次提到了压缩解压器 CompressionCodecclass，并且我们在上文中还提到了它其中的一个用于获取文件扩展名的方法 getDefaultExtension()。
压缩解压工程类 CompressionCodeFactory.class 使用的是抽象工厂的设计模式。它是一个接口，制定了一系列方法，用于创建特定压缩解压算法。下面我们来看下比较重要的几个方法：
1. createOutputStream() 方法对数据流进行压缩。
图 12. 代码示例
图 12. 代码示例
此方法提供了方法重载。
① 基于流的压缩处理；
② 基于压缩机 Compress.class 的压缩处理
2. createInputStream() 方法对数据流进行解压。
图 13. 代码示例
图 13. 代码示例
这里的解压方法同样提供了方法重载。
① 基于流的解压处理；
② 基于解压机 Decompressor.class 的解压处理；
关于压缩/解压流与压缩/解压机会在下面的文章中我们会详细讲解。此处暂作了解。
3. getCompressorType() 返回需要的编码器的类型。
getDefaultExtension() 获取对应文件扩展名的方法。前文已提到过，不再敖述。
压缩机 Compressor 和解压机 Decompressor
前面在编码解码器部分的 createInputStream() 和 createInputStream() 方法中我们提到过 Compressor.class 和 Decompressor.class 对象。在 Hadoop 的实现中，数据编码器和解码器被抽象成了两个接口：
1. org.apache.hadoop.io.compress.Compressor;
2. org.apache.hadoop.io.compress.Decompressor;
它们规定了一系列的方法，所以在 Hadoop 内部的编码/解码算法实现都需要实现对应的接口。在实际的数据压缩与解压缩过程，Hadoop 为用户提供了统一的 I/O 流处理模式。
我们看一下压缩机 Compressor.class，代码如下：
图 14. 代码示例
图 14. 代码示例
① setInput() 方法接收数据到内部缓冲区，可以多次调用；
② needsInput() 方法用于检查缓冲区是否已满。如果是 false 则说明当前的缓冲区已满；
③ getBytesRead() 输入未压缩字节的总数；
④ getBytesWritten() 输出压缩字节的总数；
⑤ finish() 方法结束数据输入的过程；
⑥ finished() 方法用于检查是否已经读取完所有的等待压缩的数据。如果返回 false，表明压缩器中还有未读取的压缩数据，可以继续通过 compress() 方法读取；
⑦ compress() 方法获取压缩后的数据，释放缓冲区空间；
⑧ reset() 方法用于重置压缩器，以处理新的输入数据集合；
⑨ end() 方法用于关闭解压缩器并放弃所有未处理的输入；
⑩ reinit() 方法更进一步允许使用 Hadoop 的配置系统，重置并重新配置压缩器；
为了提高压缩效率，并不是每次用户调用 setInput() 方法，压缩机就会立即工作，所以，为了通知压缩机所有数据已经写入，必须使用 finish() 方法。finish() 调用结束后，压缩机缓冲区中保持的已经压缩的数据，可以继续通过 compress() 方法获得。至于要判断压缩机中是否还有未读取的压缩数据，则需要利用 finished() 方法来判断。
压缩流 CompressionOutputStream 和解压缩流 CompressionInputStream
前文编码解码器部分提到过 createInputStream() 方法返回 CompressionOutputStream 对象，createInputStream() 方法返回 CompressionInputStream 对象。这两个类分别继承自 java.io.OutputStream 和 java.io.InputStream。从而我们不难理解，这两个对象的作用了吧。
我们来看下 CompressionInputStream.class 的代码：
图 15. 代码示例
图 15. 代码示例
可以看到 CompressionOutputStream 实现了 OutputStream 的 close() 方法和 flush() 方法，但用于输出数据的 write() 方法以及用于结束压缩过程并将输入写到底层流的 finish() 方法和重置压缩状态的 resetState() 方法还是抽象方法，需要 CompressionOutputStream 的子类实现。
Hadoop 压缩框架中为我们提供了一个实现了 CompressionOutputStream 类通用的子类 CompressorStream.class。
图 16. 代码示例
图 16. 代码示例
CompressorStream.class 提供了三个不同的构造函数，CompressorStream 需要的底层输出流 out 和压缩时使用的压缩器，都作为参数传入构造函数。另一个参数是 CompressorStream 工作时使用的缓冲区 buffer 的大小，构造时会利用这个参数分配该缓冲区。第一个可以手动设置缓冲区大小，第二个默认 512，第三个没有缓冲区且不可使用压缩器。
图 17. 代码示例
图 17. 代码示例
在 write()、compress()、finish() 以及 resetState() 方法中，我们发现了压缩机 Compressor 的身影，前面文章我们已经介绍过压缩机的的实现过程，通过调用 setInput() 方法将待压缩数据填充到内部缓冲区，然后调用 needsInput() 方法检查缓冲区是否已满，如果缓冲区已满，将调用 compress() 方法对数据进行压缩。流程如下图所示：
图 18. 调用流程图
图 18. 调用流程图
结束语
本文深入到 Hadoop 平台压缩框架内部，对其核心代码以及各压缩格式的效率进行对比分析，以帮助读者在使用 Hadoop 平台时，可以通过对数据进行压缩处理来提高数据处理效率。当再次面临海量数据处理时， Hadoop 平台的压缩机制可以让我们事半功倍。
相关主题
Hadoop 在线 API
《Hadoop 技术内幕深入解析 HADOOP COMMON 和 HDFS 架构设计与实现原理》
developerWorks 开源技术主题：查找丰富的操作信息、工具和项目更新，帮助您掌握开源技术并将其用于 IBM 产品。
posted @
2017-09-14 17:35 xzc 阅读(553) |
评论 (0) |
编辑 收藏Linux系统查看当前主机CPU、内存、机器型号及主板信息：
查看CPU信息（型号）
# cat /proc/cpuinfo | grep name | cut -f2 -d: | uniq -c
查看内存信息
# cat /proc/meminfo
查看主板型号：
# dmidecode |grep -A16 "System Information$"
查看机器型号
# dmidecode | grep "Product Name"
查看当前操作系统内核信息
# uname -a
查看当前操作系统发行版信息
# cat /etc/issue | grep Linux
posted @
2017-09-10 16:37 xzc 阅读(236) |
评论 (0) |
编辑 收藏posted @
2017-09-07 11:37 xzc 阅读(270) |
评论 (0) |
编辑 收藏posted @
2017-08-30 21:05 xzc 阅读(303) |
评论 (0) |
编辑 收藏1. 日期输出格式化
所有日期、时间的api都在datetime模块内。
1. datetime => string
now = datetime.datetime.now()
now.strftime('%Y-%m-%d %H:%M:%S')
#输出2012-03-05 16:26:23.870105
strftime是datetime类的实例方法。
2. string => datetime
t_str = '2012-03-05 16:26:23'
d = datetime.datetime.strptime(t_str, '%Y-%m-%d %H:%M:%S')
strptime是datetime类的静态方法。
2. 日期比较操作
在datetime模块中有timedelta类，这个类的对象用于表示一个时间间隔，比如两个日期或者时间的差别。
构造方法：
datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)
所有的参数都有默认值0，这些参数可以是int或float，正的或负的。
可以通过timedelta.days、tiemdelta.seconds等获取相应的时间值。
timedelta类的实例，支持加、减、乘、除等操作，所得的结果也是timedelta类的实例。比如：
year = timedelta(days=365)
ten_years = year *10
nine_years = ten_years - year
同时，date、time和datetime类也支持与timedelta的加、减运算。
datetime1 = datetime2 +/- timedelta
timedelta = datetime1 - datetime2
这样，可以很方便的实现一些功能。
1. 两个日期相差多少天。
d1 = datetime.datetime.strptime('2012-03-05 17:41:20', '%Y-%m-%d %H:%M:%S')
d2 = datetime.datetime.strptime('2012-03-02 17:41:20', '%Y-%m-%d %H:%M:%S')
delta = d1 - d2
print delta.days
输出：3
2. 今天的n天后的日期。
now = datetime.datetime.now()
delta = datetime.timedelta(days=3)
n_days = now + delta
print n_days.strftime('%Y-%m-%d %H:%M:%S')
输出：2012-03-08 17:44:50
#coding=utf-8
import datetime
now=datetime.datetime.now()
print now
#将日期转化为字符串 datetime => string
print now.strftime('%Y-%m-%d %H:%M:%S')
t_str = '2012-03-05 16:26:23'
#将字符串转换为日期 string => datetime
d=datetime.datetime.strptime(t_str,'%Y-%m-%d %H:%M:%S')
print d
#在datetime模块中有timedelta类，这个类的对象用于表示一个时间间隔，比如两个日#期或者时间的差别。
#计算两个日期的间隔
d1 = datetime.datetime.strptime('2012-03-05 17:41:20', '%Y-%m-%d %H:%M:%S')
d2 = datetime.datetime.strptime('2012-03-02 17:41:20', '%Y-%m-%d %H:%M:%S')
delta = d1 - d2
print delta.days
print delta
#今天的n天后的日期。
now=datetime.datetime.now()
delta=datetime.timedelta(days=3)
n_days=now+delta
print n_days.strftime('%Y-%m-%d %H:%M:%S')
posted @
2017-08-14 23:09 xzc 阅读(1361) |
评论 (0) |
编辑 收藏Shell中并没有真正意义的多线程，要实现多线程可以启动多个后端进程，最大程度利用cpu性能。
直接看代码示例吧。
(1) 顺序执行的代码
1 #!/bin/bash 2 date 3 for i in `seq 1 5` 4 do 5 { 6 echo "sleep 5" 7 sleep 5 8 } 9 done 10 date 输出：
Sat Nov 19 09:21:51 CST 2016 sleep 5 sleep 5 sleep 5 sleep 5 sleep 5 Sat Nov 19 09:22:16 CST 2016
(2) 并行代码
使用'&'+wait 实现“多进程”实现
1 #!/bin/bash 2 date 3 for i in `seq 1 5` 4 do 5 { 6 echo "sleep 5" 7 sleep 5 8 } & 9 done 10 wait ##等待所有子后台进程结束 11 date输出：
Sat Nov 19 09:25:07 CST 2016 sleep 5 sleep 5 sleep 5 sleep 5 sleep 5 Sat Nov 19 09:25:12 CST 2016
(3) 对于大量处理任务如何实现启动后台进程的数量可控？
简单的方法可以使用2层for/while循环实现，每次wait内层循环的多个后台程序执行完成。
但是这种方式的问题是，如果内层循环有“慢节点”可能导致整个任务的执行执行时间长。
更高级的实现可以看(4)
(4) 使用命名管道(fifo)实现每次启动后台进程数量可控。
1 #!/bin/bash 2 3 function my_cmd(){ 4 t=$RANDOM 5 t=$[t%15] 6 sleep $t 7 echo "sleep $t s" 8 } 9 10 tmp_fifofile="/tmp/$$.fifo" 11 mkfifo $tmp_fifofile # 新建一个fifo类型的文件 12 exec 6<>$tmp_fifofile # 将fd6指向fifo类型 13 rm $tmp_fifofile #删也可以 14 15 thread_num=5 # 最大可同时执行线程数量 16 job_num=100 # 任务总数 17 18 #根据线程总数量设置令牌个数 19 for ((i=0;i<${thread_num};i++));do 20 echo 21 done >&6 22 23 for ((i=0;i<${job_num};i++));do # 任务数量 24 # 一个read -u6命令执行一次，就从fd6中减去一个回车符，然后向下执行， 25 # fd6中没有回车符的时候，就停在这了，从而实现了线程数量控制 26 read -u6 27 28 #可以把具体的需要执行的命令封装成一个函数 29 { 30 my_cmd 31 } & 32 33 echo >&6 # 当进程结束以后，再向fd6中加上一个回车符，即补上了read -u6减去的那个 34 done 35 36 wait 37 exec 6>&- # 关闭fd6 38 echo "over"
参考:http://lawrence-zxc.github.io/2012/06/16/shell-thread/
posted @
2017-08-02 17:01 xzc 阅读(337) |
评论 (0) |
编辑 收藏 之前在论坛看到一个关于HDFS权限的问题，当时无法回答该问题。无法回答并不意味着对HDFS权限一无所知，而是不能准确完整的阐述HDFS权限，因此决定系统地学习HDFS文件权限。HDFS的文件和目录权限模型共享了POSIX（Portable Operating System Interface，可移植操作系统接口）模型的很多部分，比如每个文件和目录与一个拥有者和组相关联，文件或者目录对于拥有者、组内的其它用户和组外的其它用户有不同的权限等。与POSIX模型不同的是，HDFS中的文件没有可执行文件的概念，因而也没有setuid和setgid，虽然目录依然保留着可执行目录的概念（x），但对于目录也没有setuid和setgid。粘贴位（sticky bit）可以用在目录上，用于阻止除超级用户，目录或文件的拥有者外的任何删除或移动目录中的文件，文件上的粘贴位不起作用。
当创建文件或目录时，拥有者为运行客户端进程的用户，组为父目录所属的组。每个访问HDFS的客户端进程有一个由用户姓名和组列表两部分组的成标识，无论何时HDFS必须对由客户端进程访问的文件或目录进行权限检查，规则如下：
- 如果进程的用户名匹配文件或目录的拥有者，那么测试拥有者权限
- 否则如果文件或目录所属的组匹配组列表中任何组，那么测试组权限
- 否则测试其它权限
如果权限检查失败，则客户端操作失败。
从hadoop-0.22开始，hadoop支持两种不同的操作模式以确定用户，分别为simple和kerberos具体使用哪个方式由参数hadoop.security.authentication设置，该参数位于core-site.xml文件中，默认值为simple。在simple模式下，客户端进程的身份由主机的操作系统确定，比如在类Unix系统中，用户名为命令whoami的输出。在kerberos模式下，客户端进程的身份由Kerberos凭证确定，比如在一个Kerberized环境中，用户可能使用kinit工具得到了一个Kerberos ticket-granting-ticket(TGT)且使用klist确定当前的principal。当映射一个Kerberosprincipal到HDFS的用户名时，除了最主要的部分外其余部分都被丢弃，比如一个principal为todd/foobar@CORP.COMPANY.COM，将映射为HDFS上的todd。无论哪种操作模式，对于HDFS来说用户标识机制都是外部的，HDFS本身没有创建用户标，建立组或者处理用户凭证的规定。
上面讨论了确定用户的两种模式，即simple和kerberos，下面学习如何确定用户组。用户组是通过由参数hadoop.security.group.mapping设置的组映射服务确定的，默认实现是org.apache.hadoop.security.JniBasedUnixGroupsMappingWithFallback，该实现首先确定Java本地接口（JNI）是否可用，如果JNI可用，该实现将使用hadoop中的API为用户解析用户组列表。如果JNI不可用，那么使用ShellBasedUnixGroupsMapping，该实现将使用Linux/Unix中的bash –cgroups命令为用户解析用户组列表。其它实现还有LdapGroupsMapping，通过直接连接LDAP服务器来解析用户组列表。对HDFS来说，用户到组的映射是在NameNode上执行的，因而NameNode的主机系统配置决定了用户的组映射。HDFS将文件或目录的用户和组存储为字符串，并且不像Linux/Unix那样可以将用户和组转换为数字。
每个针对文件或者目录的操作都将全路径名称传递到NameNode，然后对该路径的每次操作都将应用权限检查。客户端隐含地关联用户身份到NameNode的连接，减少改变现存客户端API的需要。总是存在这么一种情景，当在一个文件上的操作成功后，当重复该操作时可能失败，因为该文件或者路径中的某些目录已经不再存在。例如，当客户端第一次开始读取一个文件时，它向NameNode发出的第一个请求来发现该文件第一个块的位置，第二个寻找其他块的请求可能失败。另一方面，对于已经知道文件块的客户端来说，删除文件不会取消访问。通过添加权限，客户端对文件的访问在请求之间可能撤回，对于已经知道文件块的客户端来说，改变权限不会取消客户端的访问。
HDFS中超级用户与通常熟悉的Linux或Unix中的root用户不同，HDFS的超级用户是与NameNode进程有相同标示的用户，更简单易懂些，启动NameNode的用户就为超级用户。对于谁是超级用户没有固定的定义，当NameNode启动后，该进程的标示决定了谁是超级用户。HDFS的超级用户不必是NameNode主机的超级用户，也需用所有的集群使用相同的超级用户，出于实验目的在个人工作站上运行HDFS的人自然而然的称为超级用户而不需要任何配置。另外参数dfs.permissions.superusergroup设置了超级用户，该组中的所有用户也为超级用户。超级用户在HDFS中可以执行任何操作而针对超级用户的权限检查永远不会失败。
HDFS也提供了对POSIX ACL（访问控制列表）支持来为特定的用户或者用户组提供更加细粒度的文件权限。ACL是不同于用户和组的自然组织层次的有用的权限控制方式，ACL可以为特定的用户和组设置不同的权限，而不仅仅是文件的拥有者和文件所属的组。默认情况下，HDFS禁用ACL，因此NameNode禁止ACL的创建，为了启用ACL，需要在hdfs-site.xml中将参数dfs.namenode.acls.enabled设置为true。
访问控制列表由一组ACL项组成，每个ACL项命名了特定的用户或组，并为其授予或拒绝读，写和执行的权限，例如：
user::rw- user:bruce:rwx #effective:r-- group::r-x #effective:r-- group:sales:rwx #effective:r-- mask::r-- other::r--
每个ACL项由类型，可选的名称和权限字符串组成，它们之间使用冒号（:）。在上面的例子中文件的拥有者具有读写权限，文件所属的组具有读和执行的权限，其他用户具有读权限，这些设置与将文件设置为654等价（6表示拥有者的读写权限，5表示组的读和执行权限，4表示其他用户的读权限）。除此之外，还有两个扩展的ACL项，分别为用户bruce和组sales，并都授予了读写和执行的权限。mask项是一个特殊的项，用于过滤授予所有命名用户，命名组及未命名组的权限，即过滤除文件拥有者和其他用户(other)之外的任何ACL项。在该例子中，mask值有读权限，则bruce用户、sales组和文件所属的组只具有读权限。每个ACL必须有mask项，如果用户在设置ACL时没有使用mask项，一个mask项被自动加入到ACL中，该mask项是通过计算所有被mask过滤项的权限与（&运算）得出的。对拥有ACL的文件执行chmod实际改变的是mask项的权限，因为mask项扮演的是过滤器的角色，这将有效地约束所有扩展项的权限，而不是仅改变组的权限而可能漏掉其它扩展项的权限。
访问控制列表和默认访问控制列表存在着不同，前者定义了在执行权限检查实施的规则，后者定义了新文件或者子目录创建时自动接收的ACL项，例如：
user::rwx group::r-x other::r-x default:user::rwx default:user:bruce:rwx #effective:r-x default:group::r-x default:group:sales:rwx #effective:r-x default:mask::r-x default:other::r-x
只有目录可能拥有默认访问控制列表，当创建新文件或者子目录时，自动拷贝父辈的默认访问控制列表到自己的访问控制列表中，新的子目录也拷贝父辈默认的访问控制列表到自己的默认访问控制列表中。这样，当创建子目录时默认ACL将沿着文件系统树被任意深层次地拷贝。在新的子ACL中，准确的权限由模式参数过滤。默认的umask为022，通常新目录权限为755，新文件权限为644。模式参数为未命名用户（文件的拥有者），mask及其他用户过滤拷贝的权限值。在上面的例子中，创建权限为755的子目录时，模式对最终结果没有影响，但是如果创建权限为644的文件时，模式过滤器导致新文件的ACL中文件拥有者的权限为读写，mask的权限为读以及其他用户权限为读。mask的权限意味着用户bruce和组sales只有读权限。拷贝ACL发生在文件或子目录的创建时，后面如果修改父辈的默认ACL将不再影响已存在子类的ACL。
默认ACL必须包含所有最小要求的ACL项，包括文件拥有者项，文件所属的组项和其它用户项。如果用户没有在默认ACL中配置上述三项中的任何一个，那么该项将通过从访问ACL拷贝对应的权限来自动插入，或者如果没有访问ACL则自动插入权限位。默认ACL也必须拥有mask，如果mask没有被指定，通过计算所有被mask过滤项的权限与（&运算）自动插入mask。当一个文件拥有ACL时，权限检查的算法变为：
- 如果用户名匹配文件的拥有者，则测试拥有者权限
- 否则，如果用户名匹配命名用户项中的用户名，则测试由mask权限过滤后的该项的权限
- 否则，如果文件所属的组匹配组列表中的任何组，并且如果这些被mask过滤的权限具有访问权限，那么使用这么权限
- 否则，如果存在命名组项匹配组列表中的成员，并且如果这些被mask过滤的权限具有访问权限，那么使用这么权限
- 否则，如果文件所属的组或者任何命名组项匹配组列表中的成员，但不具备访问权限，那么访问被拒绝
- 否则测试文件的其他用户权限
最佳实践时基于传统的权限位设置大部分权限要求，然后定义少量带有特殊规则的ACL增加权限位。相比较只是用权限位的文件，使用ACL的文件会在NameNode中产生额外的内存消耗。
上面学习了HDFS中的文件权限和访问控制列表，最后学习一下如何针对权限和ACL进行配置，下表列出了其中的重要参数：
| 参数名 | 位置 | 用途 |
| dfs.permissions.enabled | hdfs-site.xml | 默认值为true，即启用权限检查。如果为 false，则禁用权限检查。 |
| hadoop.http.staticuser.user | core-site.xml | 默认值为dr.who，查看web UI的用户 |
| dfs.permissions.superusergroup | hdfs-site.xml | 超级用户的组名称，默认为supergroup |
| <fs.permissions.umask-mode | core-site.xml | 创建文件和目录时使用的umask，默认值为八进制022，每位数字对应了拥有者，组和其他用户。该值既可以使用八进制数字，如022，也可以使用符号，如u=rwx,g=r-x,o=r-x(对应022) |
| dfs.cluster.administrators | hdfs-site.xml | 被指定为ACL的集群管理员 |
| dfs.namenode.acls.enabled | hdfs-site.xml | 默认值为false，禁用ACL，设置为true则启用ACL。当ACL被禁用时，NameNode拒绝设置或者获取ACL的请求 |
posted @
2017-07-28 10:55 xzc 阅读(959) |
评论 (0) |
编辑 收藏1. crontab 命令：用于在某个时间，系统自动执行你所希望的程序文件或命令。
2. crontab 的参数
-e (edit user's crontab)
-l (list user's crontab)
-r (delete user's crontab)
-i (prompt before deleting user's crontab)
3.下面进行一个例子：在8月6号18时每隔3分钟执行以下命令：who >> /apple/test_crontab.log
步骤一：先创建一个文件cronfile:内容为如下：
*/3 18 6 8 * who >> /apple/test_crontab_log
步骤二：将文件cronfile 加入到cron守护进行（命令为：crontab cronfile）
4. 检查是否加入到守护进程cron中，用命令：crontab -l
如何出来的内容中包含你刚刚的内容，则加入成功。每隔3分钟查看下test_crontab.log文件，看看是否有内容。
5. 对crontab内容格式的解释：f1 f2 f3 f4 f5 program
f1 是表示分钟（0-59），f2 表示小时（0-23），f3 表示一个月份中的第几日（1-（31、30、29、28）），f4 表示月份（1-12），f5 表示一个星期中的第几天（0-6（0表示周日））。program 表示要执行的程式（可以理解为文件或命令）
f1：为*时候表示每隔1分钟，如果为*/n 表示每隔n分钟，如果为3，4 表示第3,4分钟，如果为2-6表示第2分钟到第6分钟。
f2：为*时候表示每隔1小说。如果为*/n 表示每隔n小时,如果为3,4 表示第3,4小时，如果为2-6表示第2小时到第6小时
f3: 为*时候表示每天。n 表示第n天
f4: 为*时候表示每月。n 表示第n个月
f5: 为*时候表示每周。0表示周日，6表示周六，1-4表示周一到周六
6. 具体例子：（来自crontab百度百科）
a. 每月每天每小时的第 0 分钟执行一次 /bin/ls : 0 * * * * /bin/ls
b. 在 12 月内, 每天的早上 6 点到 12 点中，每隔 20 分钟执行一次 /usr/bin/backup :
*/20 6-12 * 12 * /usr/bin/backup
c. 周一到周五每天下午 5:00 寄一封信给 alex_mail_name :
0 17 * * 1-5 mail -s "hi" alex_mail_name < /tmp/maildata
d. 每月每天的午夜 0 点 20 分, 2 点 20 分, 4 点 20 分....执行 echo "haha"
20 0-23/2 * * * echo "haha"
e. 晚上11点到早上8点之间每两个小时和早上8点 显示日期 0 23-7/2，8 * * * date
posted @
2017-07-27 18:59 xzc 阅读(298) |
评论 (0) |
编辑 收藏最近一段时间，在处理Shell 脚本时候，遇到时间的处理问题。 时间的加减，以及时间差的计算。
1。 时间加减
这里处理方法，是将基础的时间转变为时间戳，然后，需要增加或者改变时间，变成 秒。
如：1990-01-01 01:01:01 加上 1小时 20分
处理方法：
a.将基础时间转为时间戳
time1=$(date +%s -d '1990-01-01 01:01:01')
echo $time1
631126861 【时间戳】
b.将增加时间变成秒
[root@localhost ~]# time2=$((1*60*60+20*60))
[root@localhost ~]# echo $time2
4800
c.两个时间相加，计算出结果时间
time1=$(($time1+$time2))
time1=$(date +%Y-%m-%d\ %H:%M:%S -d "1970-01-01 UTC $time1 seconds");
echo $time1
1990-01-01 02:21:01
2。时间差计算方法
如：2010-01-01 与 2009-01-01 11:11:11 时间差
原理：同样转成时间戳，然后计算天，时，分，秒
time1=$(($(date +%s -d '2010-01-01') - $(date +%s -d '2009-01-01 11:11:11')));
echo time1
将time1 / 60 秒，就变成分了。
补充说明：
shell 单括号运算符号：
a=$(date);
等同于：a=`date`;
双括号运算符:
a=$((1+2));
echo $a;
等同于：
a=`expr 1 + 2`
posted @
2017-07-06 16:33 xzc 阅读(3317) |
评论 (1) |
编辑 收藏可参照：http://www.voidcn.com/blog/Vindra/article/p-4917667.html
一、get请求
curl "http://www.baidu.com" 如果这里的URL指向的是一个文件或者一幅图都可以直接下载到本地
curl -i "http://www.baidu.com" 显示全部信息
curl -l "http://www.baidu.com" 只显示头部信息
curl -v "http://www.baidu.com" 显示get请求全过程解析
wget "http://www.baidu.com"也可以
二、post请求
curl -d "param1=value1¶m2=value2" "http://www.baidu.com"
三、json格式的post请求
curl -l -H "Content-type: application/json" -X POST -d '{"phone":"13521389587","password":"test"}' http://domain/apis/users.json
例如：
curl -l -H "Content-type: application/json" -X POST -d '{"ver": "1.0","soa":{"req":"123"},"iface":"me.ele.lpdinfra.prediction.service.PredictionService","method":"restaurant_make_order_time","args":{"arg2":"\"stable\"","arg1":"{\"code\":[\"WIND\"],\"temperature\":11.11}","arg0":"{\"tracking_id\":\"100000000331770936\",\"eleme_order_id\":\"100000000331770936\",\"platform_id\":\"4\",\"restaurant_id\":\"482571\",\"dish_num\":1,\"dish_info\":[{\"entity_id\":142547763,\"quantity\":1,\"category_id\":1,\"dish_name\":\"[0xe7][0x89][0xb9][0xe4][0xbb][0xb7][0xe8][0x85][0x8a][0xe5][0x91][0xb3][0xe5][0x8f][0x89][0xe7][0x83][0xa7][0xe5][0x8f][0x8c][0xe6][0x8b][0xbc][0xe7][0x85][0xb2][0xe4][0xbb][0x94][0xe9][0xa5][0xad]\",\"price\":31.0}],\"merchant_location\":{\"longitude\":\"121.47831425\",\"latitude\":\"31.27576153\"},\"customer_location\":{\"longitude\":\"121.47831425\",\"latitude\":\"31.27576153\"},\"created_at\":1477896550,\"confirmed_at\":1477896550,\"dishes_total_price\":0.0,\"food_boxes_total_price\":2.0,\"delivery_total_price\":2.0,\"pay_amount\":35.0,\"city_id\":\"1\"}"}}' http://vpcb-lpdinfra-stream-1.vm.elenet.me:8989/rpc
ps：json串内层参数需要格式化
posted @
2017-05-18 11:28 xzc 阅读(1639) |
评论 (1) |
编辑 收藏
1)统计80端口连接数
netstat -nat|grep -i "80"|wc -l
2）统计httpd协议连接数
ps -ef|grep httpd|wc -l
3）、统计已连接上的，状态为“established
netstat -na|grep ESTABLISHED|wc -l
4)、查出哪个IP地址连接最多,将其封了.
netstat -na|grep ESTABLISHED|awk {print $5}|awk -F: {print $1}|sort|uniq -c|sort -r +0n
netstat -na|grep SYN|awk {print $5}|awk -F: {print $1}|sort|uniq -c|sort -r +0n
---------------------------------------------------------------------------------------------
1、查看apache当前并发访问数：
netstat -an | grep ESTABLISHED | wc -l
对比httpd.conf中MaxClients的数字差距多少。
2、查看有多少个进程数：
ps aux|grep httpd|wc -l
3、可以使用如下参数查看数据
server-status?auto
#ps -ef|grep httpd|wc -l
1388
统计httpd进程数，连个请求会启动一个进程，使用于Apache服务器。
表示Apache能够处理1388个并发请求，这个值Apache可根据负载情况自动调整。
#netstat -nat|grep -i "80"|wc -l
4341
netstat -an会打印系统当前网络链接状态，而grep -i "80"是用来提取与80端口有关的连接的，wc -l进行连接数统计。
最终返回的数字就是当前所有80端口的请求总数。
#netstat -na|grep ESTABLISHED|wc -l
376
netstat -an会打印系统当前网络链接状态，而grep ESTABLISHED 提取出已建立连接的信息。 然后wc -l统计。
最终返回的数字就是当前所有80端口的已建立连接的总数。
netstat -nat||grep ESTABLISHED|wc - 可查看所有建立连接的详细记录
查看Apache的并发请求数及其TCP连接状态：
Linux命令：
netstat -n | awk '/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}'
返回结果示例：
LAST_ACK 5
SYN_RECV 30
ESTABLISHED 1597
FIN_WAIT1 51
FIN_WAIT2 504
TIME_WAIT 1057
其中的
SYN_RECV表示正在等待处理的请求数；
ESTABLISHED表示正常数据传输状态；
TIME_WAIT表示处理完毕，等待超时结束的请求数。
---------------------------------------------------------------------------------------------
查看httpd进程数（即prefork模式下Apache能够处理的并发请求数）：
Linux命令：
ps -ef | grep httpd | wc -l
查看Apache的并发请求数及其TCP连接状态：
Linux命令：
netstat -n | awk '/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}'
返回结果示例：
LAST_ACK 5
SYN_RECV 30
ESTABLISHED 1597
FIN_WAIT1 51
FIN_WAIT2 504
TIME_WAIT 1057
说明:
SYN_RECV表示正在等待处理的请求数；
ESTABLISHED表示正常数据传输状态；
TIME_WAIT表示处理完毕，等待超时结束的请求数。
posted @
2017-05-17 23:12 xzc 阅读(1460) |
评论 (2) |
编辑 收藏一、回收站简介：
在HDFS里，删除文件时，不会真正的删除，其实是放入回收站/trash，回收站里的文件可以快速恢复。
可以设置一个时间阀值，当回收站里文件的存放时间超过这个阀值或是回收站被清空时，文件才会被彻底删除，并且释放占用的数据块。
二、实例：
Hadoop的回收站trash功能默认是关闭的，所以需要在core-site.xml中手动开启。
1、修改core-site.xml，增加：
<property> <name>fs.trash.interval</name> <value>1440</value> <description>Number of minutes between trash checkpoints. If zero, the trash feature is disabled. </description> </property>
默认是0，单位是分钟，这里设置为1天。
删除数据rm后，会将数据move到当前文件夹下的.Trash目录。
2、测试
1）、新建目录input
hadoop/bin/hadoop fs -mkdir input
2）、上传文件
root@master:/data/soft# hadoop/bin/hadoop fs -copyFromLocal /data/soft/file0* input
3）、删除目录input
[root@master data]# hadoop fs -rmr input Moved to trash: hdfs://master:9000/user/root/input
4）、查看当前目录
[root@master data]# hadoop fs -ls Found 2 items drwxr-xr-x - root supergroup 0 2011-02-12 22:17 /user/root/.Trash
发现input删除了，多了一个目录.Trash
5）、恢复刚刚删除的目录
[root@master data]# hadoop fs -mv /user/root/.Trash/Current/user/root/input /user/root/input
6）、查看恢复的数据
[root@master data]# hadoop fs -ls input Found 2 items -rw-r--r-- 3 root supergroup 22 2011-02-12 17:40 /user/root/input/file01 -rw-r--r-- 3 root supergroup 28 2011-02-12 17:40 /user/root/input/file02
7）、删除.Trash目录(清理垃圾)
[root@master data]# hadoop fs -rmr .Trash Deleted hdfs://master:9000/user/root/.Trash
posted @
2017-05-12 11:20 xzc 阅读(211) |
评论 (0) |
编辑 收藏posted @
2017-05-10 10:49 xzc 阅读(314) |
评论 (0) |
编辑 收藏
一、为什么需要消息系统
1.解耦： 允许你独立的扩展或修改两边的处理过程，只要确保它们遵守同样的接口约束。 2.冗余： 消息队列把数据进行持久化直到它们已经被完全处理，通过这一方式规避了数据丢失风险。许多消息队列所采用的"插入-获取-删除"范式中，在把一个消息从队列中删除之前，需要你的处理系统明确的指出该消息已经被处理完毕，从而确保你的数据被安全的保存直到你使用完毕。 3.扩展性： 因为消息队列解耦了你的处理过程，所以增大消息入队和处理的频率是很容易的，只要另外增加处理过程即可。 4.灵活性 & 峰值处理能力： 在访问量剧增的情况下，应用仍然需要继续发挥作用，但是这样的突发流量并不常见。如果为以能处理这类峰值访问为标准来投入资源随时待命无疑是巨大的浪费。使用消息队列能够使关键组件顶住突发的访问压力，而不会因为突发的超负荷的请求而完全崩溃。 5.可恢复性： 系统的一部分组件失效时，不会影响到整个系统。消息队列降低了进程间的耦合度，所以即使一个处理消息的进程挂掉，加入队列中的消息仍然可以在系统恢复后被处理。 6.顺序保证： 在大多使用场景下，数据处理的顺序都很重要。大部分消息队列本来就是排序的，并且能保证数据会按照特定的顺序来处理。（Kafka 保证一个 Partition 内的消息的有序性） 7.缓冲： 有助于控制和优化数据流经过系统的速度，解决生产消息和消费消息的处理速度不一致的情况。 8.异步通信： 很多时候，用户不想也不需要立即处理消息。消息队列提供了异步处理机制，允许用户把一个消息放入队列，但并不立即处理它。想向队列中放入多少消息就放多少，然后在需要的时候再去处理它们。
二、kafka 架构
2.1 拓扑结构
如下图：
图.1
2.2 相关概念
如图.1中，kafka 相关名词解释如下：
1.producer： 消息生产者，发布消息到 kafka 集群的终端或服务。 2.broker： kafka 集群中包含的服务器。 3.topic： 每条发布到 kafka 集群的消息属于的类别，即 kafka 是面向 topic 的。 4.partition： partition 是物理上的概念，每个 topic 包含一个或多个 partition。kafka 分配的单位是 partition。 5.consumer： 从 kafka 集群中消费消息的终端或服务。 6.Consumer group： high-level consumer API 中，每个 consumer 都属于一个 consumer group，每条消息只能被 consumer group 中的一个 Consumer 消费，但可以被多个 consumer group 消费。 7.replica： partition 的副本，保障 partition 的高可用。 8.leader： replica 中的一个角色， producer 和 consumer 只跟 leader 交互。 9.follower： replica 中的一个角色，从 leader 中复制数据。 10.controller： kafka 集群中的其中一个服务器，用来进行 leader election 以及 各种 failover。 12.zookeeper： kafka 通过 zookeeper 来存储集群的 meta 信息。
2.3 zookeeper 节点
kafka 在 zookeeper 中的存储结构如下图所示：
图.2
三、producer 发布消息
3.1 写入方式
producer 采用 push 模式将消息发布到 broker，每条消息都被 append 到 patition 中，属于顺序写磁盘（顺序写磁盘效率比随机写内存要高，保障 kafka 吞吐率）。
3.2 消息路由
producer 发送消息到 broker 时，会根据分区算法选择将其存储到哪一个 partition。其路由机制为：
1. 指定了 patition，则直接使用； 2. 未指定 patition 但指定 key，通过对 key 的 value 进行hash 选出一个 patition 3. patition 和 key 都未指定，使用轮询选出一个 patition。
附上 java 客户端分区源码，一目了然：
//创建消息实例 public ProducerRecord(String topic, Integer partition, Long timestamp, K key, V value) { if (topic == null) throw new IllegalArgumentException("Topic cannot be null"); if (timestamp != null && timestamp < 0) throw new IllegalArgumentException("Invalid timestamp " + timestamp); this.topic = topic; this.partition = partition; this.key = key; this.value = value; this.timestamp = timestamp; } //计算 patition，如果指定了 patition 则直接使用，否则使用 key 计算 private int partition(ProducerRecord<K, V> record, byte[] serializedKey , byte[] serializedValue, Cluster cluster) { Integer partition = record.partition(); if (partition != null) { List<PartitionInfo> partitions = cluster.partitionsForTopic(record.topic()); int lastPartition = partitions.size() - 1; if (partition < 0 || partition > lastPartition) { throw new IllegalArgumentException(String.format("Invalid partition given with record: %d is not in the range [0...%d].", partition, lastPartition)); } return partition; } return this.partitioner.partition(record.topic(), record.key(), serializedKey, record.value(), serializedValue, cluster); } // 使用 key 选取 patition public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) { List<PartitionInfo> partitions = cluster.partitionsForTopic(topic); int numPartitions = partitions.size(); if (keyBytes == null) { int nextValue = counter.getAndIncrement(); List<PartitionInfo> availablePartitions = cluster.availablePartitionsForTopic(topic); if (availablePartitions.size() > 0) { int part = DefaultPartitioner.toPositive(nextValue) % availablePartitions.size(); return availablePartitions.get(part).partition(); } else { return DefaultPartitioner.toPositive(nextValue) % numPartitions; } } else { //对 keyBytes 进行 hash 选出一个 patition return DefaultPartitioner.toPositive(Utils.murmur2(keyBytes)) % numPartitions; } }3.3 写入流程
producer 写入消息序列图如下所示：
图.3
流程说明：
1. producer 先从 zookeeper 的 "/brokers/.../state" 节点找到该 partition 的 leader 2. producer 将消息发送给该 leader 3. leader 将消息写入本地 log 4. followers 从 leader pull 消息，写入本地 log 后 leader 发送 ACK 5. leader 收到所有 ISR 中的 replica 的 ACK 后，增加 HW（high watermark，最后 commit 的 offset） 并向 producer 发送 ACK
3.4 producer delivery guarantee
一般情况下存在三种情况：
1. At most once 消息可能会丢，但绝不会重复传输 2. At least one 消息绝不会丢，但可能会重复传输 3. Exactly once 每条消息肯定会被传输一次且仅传输一次
当 producer 向 broker 发送消息时，一旦这条消息被 commit，由于 replication 的存在，它就不会丢。但是如果 producer 发送数据给 broker 后，遇到网络问题而造成通信中断，那 Producer 就无法判断该条消息是否已经 commit。虽然 Kafka 无法确定网络故障期间发生了什么，但是 producer 可以生成一种类似于主键的东西，发生故障时幂等性的重试多次，这样就做到了 Exactly once，但目前还并未实现。所以目前默认情况下一条消息从 producer 到 broker 是确保了 At least once，可通过设置 producer 异步发送实现At most once。
四、broker 保存消息
4.1 存储方式
物理上把 topic 分成一个或多个 patition（对应 server.properties 中的 num.partitions=3 配置），每个 patition 物理上对应一个文件夹（该文件夹存储该 patition 的所有消息和索引文件），如下：
图.4
4.2 存储策略
无论消息是否被消费，kafka 都会保留所有消息。有两种策略可以删除旧数据：
1. 基于时间：log.retention.hours=168 2. 基于大小：log.retention.bytes=1073741824
需要注意的是，因为Kafka读取特定消息的时间复杂度为O(1)，即与文件大小无关，所以这里删除过期文件与提高 Kafka 性能无关。
4.3 topic 创建与删除
4.3.1 创建 topic
创建 topic 的序列图如下所示：
图.5
流程说明：
1. controller 在 ZooKeeper 的 /brokers/topics 节点上注册 watcher，当 topic 被创建，则 controller 会通过 watch 得到该 topic 的 partition/replica 分配。 2. controller从 /brokers/ids 读取当前所有可用的 broker 列表，对于 set_p 中的每一个 partition： 2.1 从分配给该 partition 的所有 replica（称为AR）中任选一个可用的 broker 作为新的 leader，并将AR设置为新的 ISR 2.2 将新的 leader 和 ISR 写入 /brokers/topics/[topic]/partitions/[partition]/state 3. controller 通过 RPC 向相关的 broker 发送 LeaderAndISRRequest。
4.3.2 删除 topic
删除 topic 的序列图如下所示：
图.6
流程说明：
1. controller 在 zooKeeper 的 /brokers/topics 节点上注册 watcher，当 topic 被删除，则 controller 会通过 watch 得到该 topic 的 partition/replica 分配。 2. 若 delete.topic.enable=false，结束；否则 controller 注册在 /admin/delete_topics 上的 watch 被 fire，controller 通过回调向对应的 broker 发送 StopReplicaRequest。
五、kafka HA
5.1 replication
如图.1所示，同一个 partition 可能会有多个 replica（对应 server.properties 配置中的 default.replication.factor=N）。没有 replica 的情况下，一旦 broker 宕机，其上所有 patition 的数据都不可被消费，同时 producer 也不能再将数据存于其上的 patition。引入replication 之后，同一个 partition 可能会有多个 replica，而这时需要在这些 replica 之间选出一个 leader，producer 和 consumer 只与这个 leader 交互，其它 replica 作为 follower 从 leader 中复制数据。
Kafka 分配 Replica 的算法如下：
1. 将所有 broker（假设共 n 个 broker）和待分配的 partition 排序 2. 将第 i 个 partition 分配到第（i mod n）个 broker 上 3. 将第 i 个 partition 的第 j 个 replica 分配到第（(i + j) mode n）个 broker上
5.2 leader failover
当 partition 对应的 leader 宕机时，需要从 follower 中选举出新 leader。在选举新leader时，一个基本的原则是，新的 leader 必须拥有旧 leader commit 过的所有消息。
kafka 在 zookeeper 中（/brokers/.../state）动态维护了一个 ISR（in-sync replicas），由3.3节的写入流程可知 ISR 里面的所有 replica 都跟上了 leader，只有 ISR 里面的成员才能选为 leader。对于 f+1 个 replica，一个 partition 可以在容忍 f 个 replica 失效的情况下保证消息不丢失。
当所有 replica 都不工作时，有两种可行的方案：
1. 等待 ISR 中的任一个 replica 活过来，并选它作为 leader。可保障数据不丢失，但时间可能相对较长。 2. 选择第一个活过来的 replica（不一定是 ISR 成员）作为 leader。无法保障数据不丢失，但相对不可用时间较短。
kafka 0.8.* 使用第二种方式。
kafka 通过 Controller 来选举 leader，流程请参考5.3节。
5.3 broker failover
kafka broker failover 序列图如下所示：
图.7
流程说明：
1. controller 在 zookeeper 的 /brokers/ids/[brokerId] 节点注册 Watcher，当 broker 宕机时 zookeeper 会 fire watch 2. controller 从 /brokers/ids 节点读取可用broker 3. controller决定set_p，该集合包含宕机 broker 上的所有 partition 4. 对 set_p 中的每一个 partition 4.1 从/brokers/topics/[topic]/partitions/[partition]/state 节点读取 ISR 4.2 决定新 leader（如4.3节所描述） 4.3 将新 leader、ISR、controller_epoch 和 leader_epoch 等信息写入 state 节点 5. 通过 RPC 向相关 broker 发送 leaderAndISRRequest 命令
5.4 controller failover
当 controller 宕机时会触发 controller failover。每个 broker 都会在 zookeeper 的 "/controller" 节点注册 watcher，当 controller 宕机时 zookeeper 中的临时节点消失，所有存活的 broker 收到 fire 的通知，每个 broker 都尝试创建新的 controller path，只有一个竞选成功并当选为 controller。
当新的 controller 当选时，会触发 KafkaController.onControllerFailover 方法，在该方法中完成如下操作：
1. 读取并增加 Controller Epoch。 2. 在 reassignedPartitions Patch(/admin/reassign_partitions) 上注册 watcher。 3. 在 preferredReplicaElection Path(/admin/preferred_replica_election) 上注册 watcher。 4. 通过 partitionStateMachine 在 broker Topics Patch(/brokers/topics) 上注册 watcher。 5. 若 delete.topic.enable=true（默认值是 false），则 partitionStateMachine 在 Delete Topic Patch(/admin/delete_topics) 上注册 watcher。 6. 通过 replicaStateMachine在 Broker Ids Patch(/brokers/ids)上注册Watch。 7. 初始化 ControllerContext 对象，设置当前所有 topic，“活”着的 broker 列表，所有 partition 的 leader 及 ISR等。 8. 启动 replicaStateMachine 和 partitionStateMachine。 9. 将 brokerState 状态设置为 RunningAsController。 10. 将每个 partition 的 Leadership 信息发送给所有“活”着的 broker。 11. 若 auto.leader.rebalance.enable=true（默认值是true），则启动 partition-rebalance 线程。 12. 若 delete.topic.enable=true 且Delete Topic Patch(/admin/delete_topics)中有值，则删除相应的Topic。
6. consumer 消费消息
6.1 consumer API
kafka 提供了两套 consumer API：
1. The high-level Consumer API 2. The SimpleConsumer API
其中 high-level consumer API 提供了一个从 kafka 消费数据的高层抽象，而 SimpleConsumer API 则需要开发人员更多地关注细节。
6.1.1 The high-level consumer API
high-level consumer API 提供了 consumer group 的语义，一个消息只能被 group 内的一个 consumer 所消费，且 consumer 消费消息时不关注 offset，最后一个 offset 由 zookeeper 保存。
使用 high-level consumer API 可以是多线程的应用，应当注意：
1. 如果消费线程大于 patition 数量，则有些线程将收不到消息 2. 如果 patition 数量大于线程数，则有些线程多收到多个 patition 的消息 3. 如果一个线程消费多个 patition，则无法保证你收到的消息的顺序，而一个 patition 内的消息是有序的
6.1.2 The SimpleConsumer API
如果你想要对 patition 有更多的控制权，那就应该使用 SimpleConsumer API，比如：
1. 多次读取一个消息 2. 只消费一个 patition 中的部分消息 3. 使用事务来保证一个消息仅被消费一次
但是使用此 API 时，partition、offset、broker、leader 等对你不再透明，需要自己去管理。你需要做大量的额外工作：
1. 必须在应用程序中跟踪 offset，从而确定下一条应该消费哪条消息 2. 应用程序需要通过程序获知每个 Partition 的 leader 是谁 3. 需要处理 leader 的变更
使用 SimpleConsumer API 的一般流程如下：
1. 查找到一个“活着”的 broker，并且找出每个 partition 的 leader 2. 找出每个 partition 的 follower 3. 定义好请求，该请求应该能描述应用程序需要哪些数据 4. fetch 数据 5. 识别 leader 的变化，并对之作出必要的响应
以下针对 high-level Consumer API 进行说明。
6.2 consumer group
如 2.2 节所说， kafka 的分配单位是 patition。每个 consumer 都属于一个 group，一个 partition 只能被同一个 group 内的一个 consumer 所消费（也就保障了一个消息只能被 group 内的一个 consuemr 所消费），但是多个 group 可以同时消费这个 partition。
kafka 的设计目标之一就是同时实现离线处理和实时处理，根据这一特性，可以使用 spark/Storm 这些实时处理系统对消息在线处理，同时使用 Hadoop 批处理系统进行离线处理，还可以将数据备份到另一个数据中心，只需要保证这三者属于不同的 consumer group。如下图所示：
图.8
6.3 消费方式
consumer 采用 pull 模式从 broker 中读取数据。
push 模式很难适应消费速率不同的消费者，因为消息发送速率是由 broker 决定的。它的目标是尽可能以最快速度传递消息，但是这样很容易造成 consumer 来不及处理消息，典型的表现就是拒绝服务以及网络拥塞。而 pull 模式则可以根据 consumer 的消费能力以适当的速率消费消息。
对于 Kafka 而言，pull 模式更合适，它可简化 broker 的设计，consumer 可自主控制消费消息的速率，同时 consumer 可以自己控制消费方式——即可批量消费也可逐条消费，同时还能选择不同的提交方式从而实现不同的传输语义。
6.4 consumer delivery guarantee
如果将 consumer 设置为 autocommit，consumer 一旦读到数据立即自动 commit。如果只讨论这一读取消息的过程，那 Kafka 确保了 Exactly once。
但实际使用中应用程序并非在 consumer 读取完数据就结束了，而是要进行进一步处理，而数据处理与 commit 的顺序在很大程度上决定了consumer delivery guarantee：
1.读完消息先 commit 再处理消息。 这种模式下，如果 consumer 在 commit 后还没来得及处理消息就 crash 了，下次重新开始工作后就无法读到刚刚已提交而未处理的消息，这就对应于 At most once 2.读完消息先处理再 commit。 这种模式下，如果在处理完消息之后 commit 之前 consumer crash 了，下次重新开始工作时还会处理刚刚未 commit 的消息，实际上该消息已经被处理过了。这就对应于 At least once。 3.如果一定要做到 Exactly once，就需要协调 offset 和实际操作的输出。 精典的做法是引入两阶段提交。如果能让 offset 和操作输入存在同一个地方，会更简洁和通用。这种方式可能更好，因为许多输出系统可能不支持两阶段提交。比如，consumer 拿到数据后可能把数据放到 HDFS，如果把最新的 offset 和数据本身一起写到 HDFS，那就可以保证数据的输出和 offset 的更新要么都完成，要么都不完成，间接实现 Exactly once。（目前就 high-level API而言，offset 是存于Zookeeper 中的，无法存于HDFS，而SimpleConsuemr API的 offset 是由自己去维护的，可以将之存于 HDFS 中）
总之，Kafka 默认保证 At least once，并且允许通过设置 producer 异步提交来实现 At most once（见文章《kafka consumer防止数据丢失》）。而 Exactly once 要求与外部存储系统协作，幸运的是 kafka 提供的 offset 可以非常直接非常容易得使用这种方式。
更多关于 kafka 传输语义的信息请参考《Message Delivery Semantics》。
6.5 consumer rebalance
当有 consumer 加入或退出、以及 partition 的改变（如 broker 加入或退出）时会触发 rebalance。consumer rebalance算法如下：
1. 将目标 topic 下的所有 partirtion 排序，存于PT 2. 对某 consumer group 下所有 consumer 排序，存于 CG，第 i 个consumer 记为 Ci 3. N=size(PT)/size(CG)，向上取整 4. 解除 Ci 对原来分配的 partition 的消费权（i从0开始） 5. 将第i*N到（i+1）*N-1个 partition 分配给 Ci
在 0.8.*版本，每个 consumer 都只负责调整自己所消费的 partition，为了保证整个consumer group 的一致性，当一个 consumer 触发了 rebalance 时，该 consumer group 内的其它所有其它 consumer 也应该同时触发 rebalance。这会导致以下几个问题：
1.Herd effect 任何 broker 或者 consumer 的增减都会触发所有的 consumer 的 rebalance 2.Split Brain 每个 consumer 分别单独通过 zookeeper 判断哪些 broker 和 consumer 宕机了，那么不同 consumer 在同一时刻从 zookeeper 看到的 view 就可能不一样，这是由 zookeeper 的特性决定的，这就会造成不正确的 reblance 尝试。 3. 调整结果不可控 所有的 consumer 都并不知道其它 consumer 的 rebalance 是否成功，这可能会导致 kafka 工作在一个不正确的状态。
基于以上问题，kafka 设计者考虑在0.9.*版本开始使用中心 coordinator 来控制 consumer rebalance，然后又从简便性和验证要求两方面考虑，计划在 consumer 客户端实现分配方案。（见文章《Kafka Detailed Consumer Coordinator Design》和《Kafka Client-side Assignment Proposal》），此处不再赘述。
七、注意事项
7.1 producer 无法发送消息的问题
最开始在本机搭建了kafka伪集群，本地 producer 客户端成功发布消息至 broker。随后在服务器上搭建了 kafka 集群，在本机连接该集群，producer 却无法发布消息到 broker（奇怪也没有抛错）。最开始怀疑是 iptables 没开放，于是开放端口，结果还不行（又开始是代码问题、版本问题等等，倒腾了很久）。最后没办法，一项一项查看 server.properties 配置，发现以下两个配置：
# The address the socket server listens on. It will get the value returned from # java.net.InetAddress.getCanonicalHostName() if not configured. # FORMAT: # listeners = security_protocol://host_name:port # EXAMPLE: # listeners = PLAINTEXT://your.host.name:9092 listeners=PLAINTEXT://:9092
# Hostname and port the broker will advertise to producers and consumers. If not set,
# it uses the value for "listeners" if configured. Otherwise, it will use the value
# returned from java.net.InetAddress.getCanonicalHostName().
#advertised.listeners=PLAINTEXT://your.host.name:9092
以上说的就是 advertised.listeners 是 broker 给 producer 和 consumer 连接使用的，如果没有设置，就使用 listeners，而如果 host_name 没有设置的话，就使用 java.net.InetAddress.getCanonicalHostName() 方法返回的主机名。
修改方法：
1. listeners=PLAINTEXT://121.10.26.XXX:9092 2. advertised.listeners=PLAINTEXT://121.10.26.XXX:9092
修改后重启服务，正常工作。关于更多 kafka 配置说明，见文章《Kafka学习整理三(borker(0.9.0及0.10.0)配置)》。
八、参考文章
1. 《Kafka剖析（一）：Kafka背景及架构介绍》
2. 《Kafka设计解析（二）：Kafka High Availability （上）》
3. 《Kafka设计解析（二）：Kafka High Availability （下）》
4. 《Kafka设计解析（四）：Kafka Consumer解析》
5. 《Kafka设计解析（五）：Kafka Benchmark》
6. 《Kafka学习整理三(borker(0.9.0及0.10.0)配置)》
7. 《Using the High Level Consumer》
8. 《Using SimpleConsumer》
9. 《Consumer Client Re-Design》
10. 《Message Delivery Semantics》
11. 《Kafka Detailed Consumer Coordinator Design》
12. 《Kafka Client-side Assignment Proposal》
13. 《Kafka和DistributedLog技术对比》
14. 《kafka安装和启动》
15. 《kafka consumer防止数据丢失》
本文版权归作者和博客园共有，欢迎转载，未经同意须保留此段声明，且在文章页面明显位置给出原文连接。欢迎指正与交流。
posted @
2017-04-28 10:37 xzc 阅读(303) |
评论 (0) |
编辑 收藏1. Kerberos简介
1.1. 功能
一个安全认证协议
用tickets验证
避免本地保存密码和在互联网上传输密码
包含一个可信任的第三方
使用对称加密
客户端与服务器（非KDC）之间能够相互验证
Kerberos只提供一种功能——在网络上安全的完成用户的身份验证。它并不提供授权功能或者审计功能。
1.2. 概念
首次请求，三次通信方
- the Authentication Server
- the Ticket Granting Server
- the Service or host machine that you’re wanting access to.
图 1‑1 角色
其他知识点
- 每次通信，消息包含两部分，一部分可解码，一部分不可解码
- 服务端不会直接有KDC通信
- KDC保存所有机器的账户名和密码
- KDC本身具有一个密码
2. 3次通信
我们这里已获取服务器中的一张表（数据）的服务以为，为一个http服务。
2.1. 你和验证服务
如果想要获取http服务，你首先要向KDC表名你自己的身份。这个过程可以在你的程序启动时进行。Kerberos可以通过kinit获取。介绍自己通过未加密的信息发送至KDC获取Ticket Granting Ticket (TGT)。
（1）信息包含
Authentication Server收到你的请求后，会去数据库中验证，你是否存在。注意，仅仅是验证是否存在，不会验证对错。
如果存在，Authentication Server会产生一个随机的Session key(可以是一个64位的字符串)。这个key用于你和Ticket Granting Server (TGS)之间通信。
（2）回送信息
Authentication Server同样会发送两部分信息给你，一部分信息为TGT，通过KDC自己的密码进行加密，包含：
- 你的name/ID
- TGS的name/ID
- 时间戳
- 你的IP地址
- TGT的生命周期
- TGS session key
另外一部分通过你的密码进行加密，包含的信息有
- TGS的name/ID
- 时间戳
- 生命周期
- TGS session key
图 2‑1 第一次通信
如果你的密码是正确的，你就能解密第二部分信息，获取到TGS session key。如果，密码不正确，无法解密，则认证失败。第一部分信息TGT，你是无法解密的，但需要展示缓存起来。
2.2. 你和TGS
如果第一部分你已经成功，你已经拥有无法解密的TGT和一个TGS Session Key。
（1） 请求信息
a) 通过TGS Session Key加密的认证器部分：
b) 明文传输部分：
- 请求的Http服务名（就是请求信息）
- HTTP Service的Ticket生命周期
c) TGT部分
Ticket Granting Server收到信息后，首先检查数据库中是否包含有你请求的Http服务名。如果无，直接返回错误信息。
如果存在，则通过KDC的密码解密TGT，这个时候。我们就能获取到TGS Session key。然后，通过TGS Session key去解密你传输的第一部分认证器，获取到你的用户名和时间戳。
TGS再进行验证：
- 对比TGT中的用户名与认证器中的用户名
- 比较时间戳（网上有说认证器中的时间错和TGT中的时间错，个人觉得应该是认证器中的时间戳和系统的时间戳），不能超过一定范围
- 检查是否过期
- 检查IP地址是否一致
- 检查认证器是否已在TGS缓存中（避免应答攻击）
- 可以在这部分添加权限认证服务
TGS随机产生一个Http Service Session Key, 同时准备Http Service Ticket(ST)。
（2） 回答信息
a) 通过Http服务的密码进行加密的信息（ST）：
- 你的name/ID
- Http服务name/ID
- 你的IP地址
- 时间戳
- ST的生命周期
- Http Service Session Key
b) 通过TGS Session Key加密的信息
- Http服务name/ID
- 时间戳
- ST的生命周期
- Http Service Session Key
你收到信息后，通过TGS Session Key解密，获取到了Http Service Session Key，但是你无法解密ST。
图 2‑2 第二次通信
2.3. 你和Http服务
在前面两步成功后，以后每次获取Http服务，在Ticket没有过期，或者无更新的情况下，都可直接进行这一步。省略前面两个步骤。
（1） 请求信息
a) 通过Http Service Session Key，加密部分
b) ST
Http服务端通过自己的密码解压ST（KDC是用Http服务的密码加密的），这样就能够获取到Http Service Session Key，解密第一部分。
服务端解密好ST后，进行检查
- 对比ST中的用户名（KDC给的）与认证器中的用户名
- 比较时间戳（网上有说认证器中的时间错和TGT中的时间错，个人觉得应该是认证器中的时间戳和系统的时间戳），不能超过一定范围
- 检查是否过期
- 检查IP地址是否一致
- 检查认证器是否已在HTTP服务端的缓存中（避免应答攻击）
（2） 应答信息
a) 通过Http Service Session Key加密的信息
图 2‑3 第三次通信
你在通过缓存的Http Service Session Key解密这部分信息，然后验证是否是你想要的服务器发送给你的信息。完成你的服务器的验证。
至此，整个过程全部完成。
posted @
2017-04-25 15:56 xzc 阅读(248) |
评论 (2) |
编辑 收藏posted @
2017-04-14 11:25 xzc 阅读(543) |
评论 (2) |
编辑 收藏问题导读
1.CM的安装目录在什么位置？
2.hadoop配置文件在什么位置？
3.Cloudera manager运行所需要的信息存在什么位置？4.CM结构和功能是什么？
1. 相关目录- /var/log/cloudera-scm-installer : 安装日志目录。
- /var/log/* : 相关日志文件（相关服务的及CM的）。
- /usr/share/cmf/ : 程序安装目录。
- /usr/lib64/cmf/ : Agent程序代码。
- /var/lib/cloudera-scm-server-db/data : 内嵌数据库目录。
- /usr/bin/postgres : 内嵌数据库程序。
- /etc/cloudera-scm-agent/ : agent的配置目录。
- /etc/cloudera-scm-server/ : server的配置目录。
- /opt/cloudera/parcels/ : Hadoop相关服务安装目录。
- /opt/cloudera/parcel-repo/ : 下载的服务软件包数据，数据格式为parcels。
- /opt/cloudera/parcel-cache/ : 下载的服务软件包缓存数据。
- /etc/hadoop/* : 客户端配置文件目录。
2. 配置Hadoop配置文件
配置文件放置于/var/run/cloudera-scm-agent/process/目录下。如：/var/run/cloudera-scm-agent/process/193-hdfs-NAMENODE/core-site.xml。这些配置文件是通过Cloudera Manager启动相应服务（如HDFS）时生成的，内容从数据库中获得（即通过界面配置的参数）。
在CM界面上更改配置是不会立即反映到配置文件中，这些信息会存储于数据库中，等下次重启服务时才会生成配置文件。且每次启动时都会产生新的配置文件。
CM Server主要数据库为scm基中放置配置的数据表为configs。里面包含了服务的配置信息，每一次配置的更改会把当前页面的所有配置内容添加到数据库中，以此保存配置修改历史。
scm数据库被配置成只能从localhost访问，如果需要从外部连接此数据库，修改vim /var/lib/cloudera-scm-server-db/data/pg_hba.conf文件,之后重启数据库。运行数据库的用户为cloudera-scm。
查看配置内容
- 直接查询scm数据库的configs数据表的内容。
- 访问REST API： http://hostname:7180/api/v4/cm/deployment，返回JSON格式部署配置信息。
3. 数据库Cloudera manager主要的数据库为scm,存储Cloudera manager运行所需要的信息：配置，主机，用户等。
4. CM结构CM分为Server与Agent两部分及数据库（自带更改过的嵌入Postgresql）。它主要做三件事件：
- 管理监控集群主机。
- 统一管理配置。
- 管理维护Hadoop平台系统。
实现采用C/S结构，Agent为客户端负责执行服务端发来的命令，执行方式一般为使用python调用相应的服务shell脚本。Server端为Java REST服务，提供REST API，Web管理端通过REST API调用Server端功能，Web界面使用富客户端技术（Knockout）。
- Server端主体使用Java实现。
- Agent端主体使用Python, 服务的启动通过调用相应的shell脚本进行启动，如果启动失败会重复4次调用启动脚本。
- Agent与Server保持心跳，使用Thrift RPC框架。
5. 升级在CM中可以通过界面向导升级相关服务。升级过程为三步：
- 下载服务软件包。
- 把所下载的服务软件包分发到集群中受管的机器上。
- 安装服务软件包，使用软链接的方式把服务程序目录链接到新安装的软件包目录上。
6. 卸载sudo /usr/share/cmf/uninstall-scm-express.sh, 然后删除/var/lib/cloudera-scm-server-db/目录，不然下次安装可能不成功。
7. 开启postgresql远程访问CM内嵌数据库被配置成只能从localhost访问，如果需要从外部查看数据，数据修改vim /var/lib/cloudera-scm-server-db/data/pg_hba.conf文件,之后重启数据库。运行数据库的用户为cloudera-scm。
posted @
2017-04-13 14:36 xzc 阅读(309) |
评论 (0) |
编辑 收藏- 新版本的 hbck 可以修复各种错误，修复选项是：
- （1）-fix，向下兼容用，被-fixAssignments替代
- （2）-fixAssignments，用于修复region assignments错误
- （3）-fixMeta，用于修复meta表的问题，前提是HDFS上面的region info信息有并且正确。
- （4）-fixHdfsHoles，修复region holes（空洞，某个区间没有region）问题
- （5）-fixHdfsOrphans，修复Orphan region（hdfs上面没有.regioninfo的region）
- （6）-fixHdfsOverlaps，修复region overlaps（区间重叠）问题
- （7）-fixVersionFile，修复缺失hbase.version文件的问题
- （8）-maxMerge <n> （n默认是5），当region有重叠是，需要合并region，一次合并的region数最大不超过这个值。
- （9）-sidelineBigOverlaps ，当修复region overlaps问题时，允许跟其他region重叠次数最多的一些region不参与（修复后，可以把没有参与的数据通过bulk load加载到相应的region）
- （10）-maxOverlapsToSideline <n> （n默认是2），当修复region overlaps问题时，一组里最多允许多少个region不参与
- 由于选项较多，所以有两个简写的选项
- （11） -repair，相当于-fixAssignments -fixMeta -fixHdfsHoles -fixHdfsOrphans -fixHdfsOverlaps -fixVersionFile -sidelineBigOverlaps
- （12）-repairHoles，相当于-fixAssignments -fixMeta -fixHdfsHoles -fixHdfsOrphans
-
-
-
- 新版本的 hbck
- （1）缺失hbase.version文件
- 加上选项 -fixVersionFile 解决
- （2）如果一个region即不在META表中，又不在hdfs上面，但是在regionserver的online region集合中
- 加上选项 -fixAssignments 解决
- （3）如果一个region在META表中，并且在regionserver的online region集合中，但是在hdfs上面没有
- 加上选项 -fixAssignments -fixMeta 解决，（ -fixAssignments告诉regionserver close region），（ -fixMeta删除META表中region的记录）
- （4）如果一个region在META表中没有记录，没有被regionserver服务，但是在hdfs上面有
- 加上选项 -fixMeta -fixAssignments 解决，（ -fixAssignments 用于assign region），（ -fixMeta用于在META表中添加region的记录）
- （5）如果一个region在META表中没有记录，在hdfs上面有，被regionserver服务了
- 加上选项 -fixMeta 解决，在META表中添加这个region的记录，先undeploy region，后assign
- （6）如果一个region在META表中有记录，但是在hdfs上面没有，并且没有被regionserver服务
- 加上选项 -fixMeta 解决，删除META表中的记录
- （7）如果一个region在META表中有记录，在hdfs上面也有，table不是disabled的，但是这个region没有被服务
- 加上选项 -fixAssignments 解决，assign这个region
- （8）如果一个region在META表中有记录，在hdfs上面也有，table是disabled的，但是这个region被某个regionserver服务了
- 加上选项 -fixAssignments 解决，undeploy这个region
- （9）如果一个region在META表中有记录，在hdfs上面也有，table不是disabled的，但是这个region被多个regionserver服务了
- 加上选项 -fixAssignments 解决，通知所有regionserver close region，然后assign region
- （10）如果一个region在META表中，在hdfs上面也有，也应该被服务，但是META表中记录的regionserver和实际所在的regionserver不相符
- 加上选项 -fixAssignments 解决
-
- （11）region holes
- 需要加上 -fixHdfsHoles ，创建一个新的空region，填补空洞，但是不assign 这个 region，也不在META表中添加这个region的相关信息
- （12）region在hdfs上面没有.regioninfo文件
- -fixHdfsOrphans 解决
- （13）region overlaps
- 需要加上 -fixHdfsOverlaps
-
-
- 说明：
- （1）修复region holes时，-fixHdfsHoles 选项只是创建了一个新的空region，填补上了这个区间，还需要加上-fixAssignments -fixMeta 来解决问题，（ -fixAssignments 用于assign region），（ -fixMeta用于在META表中添加region的记录），所以有了组合拳 -repairHoles 修复region holes，相当于-fixAssignments -fixMeta -fixHdfsHoles -fixHdfsOrphans
- （2） -fixAssignments，用于修复region没有assign、不应该assign、assign了多次的问题
- （3）-fixMeta，如果hdfs上面没有，那么从META表中删除相应的记录，如果hdfs上面有，在META表中添加上相应的记录信息
- （4）-repair 打开所有的修复选项，相当于-fixAssignments -fixMeta -fixHdfsHoles -fixHdfsOrphans -fixHdfsOverlaps -fixVersionFile -sidelineBigOverlaps
-
- 新版本的hbck从（1）hdfs目录（2）META（3）RegionServer这三处获得region的Table和Region的相关信息，根据这些信息判断并repair
新版本的 hbck 可以修复各种错误，修复选项是： （1）-fix，向下兼容用，被-fixAssignments替代 （2）-fixAssignments，用于修复region assignments错误 （3）-fixMeta，用于修复meta表的问题，前提是HDFS上面的region info信息有并且正确。 （4）-fixHdfsHoles，修复region holes（空洞，某个区间没有region）问题 （5）-fixHdfsOrphans，修复Orphan region（hdfs上面没有.regioninfo的region） （6）-fixHdfsOverlaps，修复region overlaps（区间重叠）问题 （7）-fixVersionFile，修复缺失hbase.version文件的问题 （8）-maxMerge <n> （n默认是5），当region有重叠是，需要合并region，一次合并的region数最大不超过这个值。 （9）-sidelineBigOverlaps ，当修复region overlaps问题时，允许跟其他region重叠次数最多的一些region不参与（修复后，可以把没有参与的数据通过bulk load加载到相应的region） （10）-maxOverlapsToSideline <n> （n默认是2），当修复region overlaps问题时，一组里最多允许多少个region不参与 由于选项较多，所以有两个简写的选项 （11） -repair，相当于-fixAssignments -fixMeta -fixHdfsHoles -fixHdfsOrphans -fixHdfsOverlaps -fixVersionFile -sidelineBigOverlaps （12）-repairHoles，相当于-fixAssignments -fixMeta -fixHdfsHoles -fixHdfsOrphans 新版本的 hbck （1）缺失hbase.version文件 加上选项 -fixVersionFile 解决 （2）如果一个region即不在META表中，又不在hdfs上面，但是在regionserver的online region集合中 加上选项 -fixAssignments 解决 （3）如果一个region在META表中，并且在regionserver的online region集合中，但是在hdfs上面没有 加上选项 -fixAssignments -fixMeta 解决，（ -fixAssignments告诉regionserver close region），（ -fixMeta删除META表中region的记录） （4）如果一个region在META表中没有记录，没有被regionserver服务，但是在hdfs上面有 加上选项 -fixMeta -fixAssignments 解决，（ -fixAssignments 用于assign region），（ -fixMeta用于在META表中添加region的记录） （5）如果一个region在META表中没有记录，在hdfs上面有，被regionserver服务了 加上选项 -fixMeta 解决，在META表中添加这个region的记录，先undeploy region，后assign （6）如果一个region在META表中有记录，但是在hdfs上面没有，并且没有被regionserver服务 加上选项 -fixMeta 解决，删除META表中的记录 （7）如果一个region在META表中有记录，在hdfs上面也有，table不是disabled的，但是这个region没有被服务 加上选项 -fixAssignments 解决，assign这个region （8）如果一个region在META表中有记录，在hdfs上面也有，table是disabled的，但是这个region被某个regionserver服务了 加上选项 -fixAssignments 解决，undeploy这个region （9）如果一个region在META表中有记录，在hdfs上面也有，table不是disabled的，但是这个region被多个regionserver服务了 加上选项 -fixAssignments 解决，通知所有regionserver close region，然后assign region （10）如果一个region在META表中，在hdfs上面也有，也应该被服务，但是META表中记录的regionserver和实际所在的regionserver不相符 加上选项 -fixAssignments 解决 （11）region holes 需要加上 -fixHdfsHoles ，创建一个新的空region，填补空洞，但是不assign 这个 region，也不在META表中添加这个region的相关信息 （12）region在hdfs上面没有.regioninfo文件 -fixHdfsOrphans 解决 （13）region overlaps 需要加上 -fixHdfsOverlaps 说明： （1）修复region holes时，-fixHdfsHoles 选项只是创建了一个新的空region，填补上了这个区间，还需要加上-fixAssignments -fixMeta 来解决问题，（ -fixAssignments 用于assign region），（ -fixMeta用于在META表中添加region的记录），所以有了组合拳 -repairHoles 修复region holes，相当于-fixAssignments -fixMeta -fixHdfsHoles -fixHdfsOrphans （2） -fixAssignments，用于修复region没有assign、不应该assign、assign了多次的问题 （3）-fixMeta，如果hdfs上面没有，那么从META表中删除相应的记录，如果hdfs上面有，在META表中添加上相应的记录信息 （4）-repair 打开所有的修复选项，相当于-fixAssignments -fixMeta -fixHdfsHoles -fixHdfsOrphans -fixHdfsOverlaps -fixVersionFile -sidelineBigOverlaps 新版本的hbck从（1）hdfs目录（2）META（3）RegionServer这三处获得region的Table和Region的相关信息，根据这些信息判断并repair
示例：
- 查看hbasemeta情况
- hbase hbck
- 1.重新修复hbase meta表（根据hdfs上的regioninfo文件，生成meta表）
- hbase hbck -fixMeta
- 2.重新将hbase meta表分给regionserver（根据meta表，将meta表上的region分给regionservere）
- hbase hbck -fixAssignments
查看hbasemeta情况 hbase hbck 1.重新修复hbase meta表（根据hdfs上的regioninfo文件，生成meta表） hbase hbck -fixMeta 2.重新将hbase meta表分给regionserver（根据meta表，将meta表上的region分给regionservere） hbase hbck -fixAssignments
- 当出现漏洞
- hbase hbck -fixHdfsHoles （新建一个region文件夹）
- hbase hbck -fixMeta （根据regioninfo生成meta表）
- hbase hbck -fixAssignments （分配region到regionserver上）
当出现漏洞 hbase hbck -fixHdfsHoles （新建一个region文件夹） hbase hbck -fixMeta （根据regioninfo生成meta表） hbase hbck -fixAssignments （分配region到regionserver上）
- 一、故障原因
- IP为10.191.135.3的服务器在2013年8月1日出现服务器重新启动的情况，导致此台服务器上的所有服务均停止。从而造成NTP服务停止。当NTP服务停止后，导致HBase集群中大部分机器时钟和主机时间不一致，造成regionserver服务中止。并在重新启动后，出现region的hole。需要对数据进行重新修复，以正常提供插入数据的服务。
-
- 二、恢复方式
- 1、集群50个regionserver，宕掉服务41个，namenode所在机器10.191.135.3不明重启（原因查找中）导致本机上的namenode、zookeeper、时间同步服务器服务挂掉。
- 2、重启hbase服务时，没能成功stop剩余的9个regionserver服务，进行了人为kill进程，
- 3、在hdfs上移走了hlog（避免启动时split log花费过多时间影响服务），然后重启hbase。发现10.191.135.30机器上的时间与时间同步服务器10.191.135.3不同步。手工同步后重启成功。hbase可以正常提供查询服务。
- 4、运行mapreduce put数据。抛出异常，数据无法正常插入；
- 5、执行/opt/hbase/bin/hbase hbck -fixAssignments，尝试重新分配region。结果显示hbase有空洞，即region之间数据不连续了；
- 6、通过上述操作可以定位是在regionserver服务宕掉的后重启的过程中丢了数据。需要进行空洞修复。然而hbase hbck命令总是只显示三条空洞。
- 7、通过编写的regionTest.jar工具进行进一步检测出空洞所在的regionname然后停掉hbase，进而进行region合并修复空洞;
- 8、合并的merge 操作需要先去.META.表里读取该region的信息，由于.META.表也在regionserver宕机过程中受到损坏，所以部分region的.META.信息没有，merge操作时就抛出空指针异常。因此只能将hdfs这些region进行移除，然后通过regionTest.jar 检测新的空洞所在的regionname，进行合并操作修复空洞；
- 9、关于region重叠，即regionname存在.META.表内，但是在hdfs上被错误的移出，并进行了region合并。这种情况下需要通过regionTest.jar检测重叠的regionname然后手动去.META.表删除，.META.表修改之后需要flush；
- 10、最后再次执行 hbase hbck 命令，hbase 所有表status ok。
-
- 三、相关命令及页面报错信息
- 1.手工同步时间命令
service ntpd stop
ntpdate -d 192.168.1.20
service ntpd start
-
-
- 2.org.apache.hadoop.hbase.client.RetriesExhaustedWithDetailsException: Failed 2 actions: WrongRegionException: 2 times, servers with issues: datanode10:60020,
at org.apache.hadoop.hbase.client.HConnectionManager$HConnectionImplementation.processBatchCallback(HConnectionManager.java:1641)
at org.apache.hadoop.hbase.client.HConnectionManager$HConnectionImplementation.processBatch(HConnectionManager.java:1409)
at org.apache.hadoop.hbase.client.HTable.flushCommits(HTable.java:949)
at org.apache.hadoop.hbase.client.HTable.doPut(HTable.java:826)
at org.apache.hadoop.hbase.client.HTable.put(HTable.java:801)
at org.apache.hadoop.hbase.mapreduce.TableOutputFormat$TableRecordWriter.write(TableOutputFormat.java:123)
at org.apache.hadoop.hbase.mapreduce.TableOutputFormat$TableRecordWriter.write(TableOutputFormat.java:84)
at org.apache.hadoop.mapred.MapTask$NewDirectOutputCollector.write(MapTask.java:533)
at org.apache.hadoop.mapreduce.task.TaskInputOutputContextImpl.write(TaskInputOutputContextImpl.java:88)
at o
-
- 3.13/08/01 18:30:02 DEBUG util.HBaseFsck: There are 22093 region info entries
ERROR: There is a hole in the region chain between +8615923208069cmnet201303072132166264580 and +861592321. You need to create a new .regioninfo and region dir in hdfs to plug the hole.
ERROR: There is a hole in the region chain between +8618375993383cmwap20130512235639430 and +8618375998629cmnet201305040821436779670. You need to create a new .regioninfo and region dir in hdfs to plug the hole.
ERROR: There is a hole in the region chain between +8618725888080cmnet201212271719506311400 and +8618725889786cmnet201302131646431671140. You need to create a new .regioninfo and region dir in hdfs to plug the hole.
ERROR: Found inconsistency in table cqgprs
Summary:
-ROOT- is okay.
Number of regions: 1
Deployed on: datanode14,60020,1375330955915
.META. is okay.
Number of regions: 1
Deployed on: datanode21,60020,1375330955825
cqgprs is okay.
Number of regions: 22057
Deployed on: datanode1,60020,1375330955761 datanode10,60020,1375330955748 datanode11,60020,1375330955736 datanode12,60020,1375330955993 datanode13,60020,1375330955951 datanode14,60020,1375330955915 datanode15,60020,1375330955882 datanode16,60020,1375330955892 datanode17,60020,1375330955864 datanode18,60020,1375330955703 datanode19,60020,1375330955910 datanode2,60020,1375330955751 datanode20,60020,1375330955849 datanode21,60020,1375330955825 datanode22,60020,1375334479752 datanode23,60020,1375330955835 datanode24,60020,1375330955932 datanode25,60020,1375330955856 datanode26,60020,1375330955807 datanode27,60020,1375330955882 datanode28,60020,1375330955785 datanode29,60020,1375330955799 datanode3,60020,1375330955778 datanode30,60020,1375330955748 datanode31,60020,1375330955877 datanode32,60020,1375330955763 datanode33,60020,1375330955755 datanode34,60020,1375330955713 datanode35,60020,1375330955768 datanode36,60020,1375330955896 datanode37,60020,1375330955884 datanode38,60020,1375330955918 datanode39,60020,1375330955881 datanode4,60020,1375330955826 datanode40,60020,1375330955770 datanode41,60020,1375330955824 datanode42,60020,1375449245386 datanode43,60020,1375330955880 datanode44,60020,1375330955902 datanode45,60020,1375330955881 datanode46,60020,1375330955841 datanode47,60020,1375330955790 datanode48,60020,1375330955848 datanode49,60020,1375330955849 datanode5,60020,1375330955880 datanode50,60020,1375330955802 datanode6,60020,1375330955753 datanode7,60020,1375330955890 datanode8,60020,1375330955967 datanode9,60020,1375330955948
test1 is okay.
Number of regions: 1
Deployed on: datanode43,60020,1375330955880
test2 is okay.
Number of regions: 1
Deployed on: datanode21,60020,1375330955825
35 inconsistencies detected.
Status: INCONSISTENT
-
- 4.hadoop jar regionTest.jar com.region.RegionReaderMain /hbase/cqgprs 检测cqgprs表里的空洞所在的regionname。
-
- 5.==================================
first endKey = +8615808059207cmnet201307102326567966800
second startKey = +8615808058578cmnet201212251545557984830
first regionNmae = cqgprs,+8615808058578cmnet201212251545557984830,1375241186209.0f8266ad7ac45be1fa7233e8ea7aeef9.
second regionNmae = cqgprs,+8615808058578cmnet201212251545557984830,1362778571889.3552d3db8166f421047525d6be39c22e.
==================================
first endKey = +8615808060140cmnet201303051801355846850
second startKey = +8615808059207cmnet201307102326567966800
first regionNmae = cqgprs,+8615808058578cmnet201212251545557984830,1362778571889.3552d3db8166f421047525d6be39c22e.
second regionNmae = cqgprs,+8615808059207cmnet201307102326567966800,1375241186209.09d489d3df513bc79bab09cec36d2bb4.
==================================
-
- 6.Usage: bin/hbase org.apache.hadoop.hbase.util.Merge [-Dfs.default.name=hdfs://nn:port] <table-name> <region-1> <region-2>
./hbase org.apache.hadoop.hbase.util.Merge -Dfs.defaultFS=hdfs://bdpha cqgprs cqgprs,+8615213741567cmnet201305251243290802280,1369877465524.3c13b460fae388b1b1a70650b66c5039. cqgprs,+8615213745577cmnet201302141725552206710,1369534940433.5de80f59071555029ac42287033a4863. &
-
- 7.13/08/01 22:24:02 WARN util.HBaseFsck: Naming new problem group: +8618225125357cmnet201212290358070667800
ERROR: (regions cqgprs,+8618225123516cmnet201304131404096748520,1375363774655.b3cf5cc752f4427a4e699270dff9839e. and cqgprs,+8618225125357cmnet201212290358070667800,1364421610707.7f7038bfbe2c0df0998a529686a3e1aa.) There is an overlap in the region chain.
13/08/01 22:24:02 WARN util.HBaseFsck: reached end of problem group: +8618225127504cmnet201302182135452100210
13/08/01 22:24:02 WARN util.HBaseFsck: Naming new problem group: +8618285642723cmnet201302031921019768070
ERROR: (regions cqgprs,+8618285277826cmnet201306170027424674330,1375363962312.9d1e93b22cec90fd75361fa65b1d20d2. and cqgprs,+8618285642723cmnet201302031921019768070,1360873307626.f631cd8c6acc5e711e651d13536abe94.) There is an overlap in the region chain.
13/08/01 22:24:02 WARN util.HBaseFsck: reached end of problem group: +8618286275556cmnet201212270713444340110
13/08/01 22:24:02 WARN util.HBaseFsck: Naming new problem group: +8618323968833cmnet201306010239025175240
ERROR: (regions cqgprs,+8618323967956cmnet201306091923411365860,1375364143678.665dba6a14ebc9971422b39e079b00ae. and cqgprs,+8618323968833cmnet201306010239025175240,1372821719159.6d2fecc1b3f9049bbca83d84231eb365.) There is an overlap in the region chain.
13/08/01 22:24:02 WARN util.HBaseFsck: reached end of problem group: +8618323992353cmnet201306012336364819810
ERROR: There is a hole in the region chain between +8618375993383cmwap20130512235639430 and +8618375998629cmnet201305040821436779670. You need to create a new .regioninfo and region dir in hdfs to plug the hole.
13/08/01 22:24:02 WARN util.HBaseFsck: Naming new problem group: +8618723686187cmnet201301191433522129820
ERROR: (regions cqgprs,+8618723683087cmnet201301300708363045080,1375364411992.4ee5787217c1da4895d95b3b92b8e3a2. and cqgprs,+8618723686187cmnet201301191433522129820,1362003066106.70b48899cc753a0036f11bb27d2194f9.) There is an overlap in the region chain.
13/08/01 22:24:02 WARN util.HBaseFsck: reached end of problem group: +8618723689138cmnet201301051742388948390
13/08/01 22:24:02 WARN util.HBaseFsck: Naming new problem group: +8618723711808cmnet201301031139206225900
ERROR: (regions cqgprs,+8618723710003cmnet201301250809235976320,1375364586329.40eed10648c9a43e3d5ce64e9d63fe00. and cqgprs,+8618723711808cmnet201301031139206225900,1361216401798.ebc442e02f5e784bce373538e06dd232.) There is an overlap in the region chain.
13/08/01 22:24:02 WARN util.HBaseFsck: reached end of problem group: +8618723714626cmnet201302122009459491970
ERROR: There is a hole in the region chain between +8618725888080cmnet201212271719506311400 and +8618725889786cmnet201302131646431671140. You need to create a new .regioninfo and region dir in hdfs to plug the hole.
-
- 8. delete '.META.','regionname','info:serverstartcode'
- delete '.META.','regionname','info:regionserver'
- delete '.META.','regionname','info:regioninfo'
-
- 9. flush '.META.'
major_compact '.META.'
posted @
2017-04-11 16:01 xzc 阅读(441) |
评论 (0) |
编辑 收藏自从开源中国的maven仓库挂了之后就一直在用国外的仓库，慢得想要砸电脑的心都有了。如果你和我一样受够了国外maven仓库的龟速下载？快试试阿里云提供的maven仓库，从此不在浪费生命……
仓库地址：http://maven.aliyun.com/nexus/#view-repositories;public~browsestorage
仓库配置
在maven的settings.xml文件里的mirrors节点，添加如下子节点：
<mirror> <id>nexus-aliyun</id> <mirrorOf>central</mirrorOf> <name>Nexus aliyun</name> <url>http://maven.aliyun.com/nexus/content/groups/public</url> </mirror>
或者直接在profiles->profile->repositories节点，添加如下子节点：
<repository> <id>nexus-aliyun</id> <name>Nexus aliyun</name> <layout>default</layout> <url>http://maven.aliyun.com/nexus/content/groups/public</url> <snapshots> <enabled>false</enabled> </snapshots> <releases> <enabled>true</enabled> </releases> </repository>
settings文件的路径
settings.xml的默认路径就：个人目录/.m2/settings.xml
如：
windowns: C:\Users\你的用户名\.m2\settings.xml
linux: /home/你的用户名/.m2/settings.xml
posted @
2017-04-11 10:08 xzc 阅读(253) |
评论 (0) |
编辑 收藏所谓BOM，全称是Byte Order Mark，它是一个Unicode字符，通常出现在文本的开头，用来标识字节序（Big/Little Endian），除此以外还可以标识编码（UTF-8/16/32），如果出现在文本中间，则解释为zero width no-break space。 注：Unicode相关知识的详细介绍请参考UTF-8, UTF-16, UTF-32 & BOM。
对于UTF-8/16/32而言，它们名字中的8/16/32指的是编码单位是多少位的，也就是说，它们的编码单位分别是8/16/32位，换算成字节就
是1/2/4字节，如果是多字节，就要牵扯到字节序，UTF-8以单字节为编码单位，所以不存在字节序。
UTF-8主要的优点是可以兼容ASCII，但如果使用BOM的话，这个好处就荡然无存了，除此以外，BOM的存在还可能引发一些问题，比如下面错误便都
有可能是BOM导致的：
- Shell: No such file or directory
- PHP: Warning: Cannot modify header information – headers already sent
在详细讨论UTF-8编码中BOM的检测与删除问题前，不妨先通过一个例子热热身：
shell> curl -s http://phone.10086.cn/ | head -1 | sed -n l
\357\273\277<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional\
//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">\r$
如上所示，前三个字节分别是357、273、277，这就是八进制的BOM。
shell> curl -s http://phone.10086.cn/ | head -1 | hexdump -C
00000000 ef bb bf 3c 21 44 4f 43 54 59 50 45 20 68 74 6d |...<!DOCTYPE htm|
00000010 6c 20 50 55 42 4c 49 43 20 22 2d 2f 2f 57 33 43 |l PUBLIC "-//W3C|
00000020 2f 2f 44 54 44 20 58 48 54 4d 4c 20 31 2e 30 20 |//DTD XHTML 1.0 |
00000030 54 72 61 6e 73 69 74 69 6f 6e 61 6c 2f 2f 45 4e |Transitional//EN|
00000040 22 20 22 68 74 74 70 3a 2f 2f 77 77 77 2e 77 33 |" "http://www.w3|
00000050 2e 6f 72 67 2f 54 52 2f 78 68 74 6d 6c 31 2f 44 |.org/TR/xhtml1/D|
00000060 54 44 2f 78 68 74 6d 6c 31 2d 74 72 61 6e 73 69 |TD/xhtml1-transi|
00000070 74 69 6f 6e 61 6c 2e 64 74 64 22 3e 0d 0a |tional.dtd">..|
如上所示，前三个字节分别是EF、BB、BF，这就是十六进制的BOM。 注：用到了第三方网站的页面，不能保证例子始终可用。
实际做项目开发时，可能会面对成百上千个文本文件，如果有几个文件混入了BOM，那么很难察觉，如果没有带BOM的UTF-8文本文件，可以用vi杜撰几
个，相关命令如下：
设置UTF-8编码：
:set fileencoding=utf-8
添加BOM：
:set bomb
删除BOM：
:set nobomb
查询BOM：
:set bomb?
如何检测UTF-8编码中的BOM呢？
shell> grep -r -I -l $'^\xEF\xBB\xBF' /path
如何删除UTF-8编码中的BOM呢？
shell> grep -r -I -l $'^\xEF\xBB\xBF' /path | xargs sed -i 's/^\xEF\xBB\xBF//;q'
推荐：如果你使用SVN的话，可以在pre-commit钩子里加上相关代码用以杜绝BOM。
#!/bin/bash
REPOS="$1"
TXN="$2"
SVNLOOK=/usr/bin/svnlook
for FILE in $($SVNLOOK changed -t "$TXN" "$REPOS" | awk '/^[AU]/ {print $NF}'); do
if $SVNLOOK cat -t "$TXN" "$REPOS" "$FILE" | grep -q $'^\xEF\xBB\xBF'; then
echo "Byte Order Mark be found in $FILE" 1>&2
exit 1
fi
done
本文用到了很多shell命令，篇幅所限，恕不详述，如果有不明白的就请自己搜索吧。
posted @
2016-09-18 09:38 xzc 阅读(938) |
评论 (0) |
编辑 收藏当我们需要把二进制转成c语言中使用的16进制字符数组时，命令xxd是很有用的。
xxd 帮助信息如下：关键选项标黑。
[root@localhost ]# xxd --help
Usage:
xxd [options] [infile [outfile]]
or
xxd -r [-s [-]offset] [-c cols] [-ps] [infile [outfile]]
Options:
-a toggle autoskip: A single '*' replaces nul-lines. Default off.
-b binary digit dump (incompatible with -p,-i,-r). Default hex.
-c cols format <cols> octets per line. Default 16 (-i: 12, -ps: 30).
-E show characters in EBCDIC. Default ASCII.
-g number of octets per group in normal output. Default 2. 每个goup的字节数，默认为2，可设置。
-h print this summary.
-i output in C include file style. ：输出为c包含文件的风格，数组方式存在。
-l len stop after <len> octets. ：转换到len个字节后停止转换。
-ps output in postscript plain hexdump style.
-r reverse operation: convert (or patch) hexdump into binary.
-r -s off revert with <off> added to file positions found in hexdump.
-s [+][-]seek start at <seek> bytes abs. (or +: rel.) infile offset.
-u use upper case hex letters. ： 字节大写方式
-v show version: "xxd V1.10 27oct98 by Juergen Weigert".
比如运行：
> xxd -g 1 -i -u -l 10000000 nm.ts > xxd_test.txt
生成的文本显示：
unsigned char __0513_1634_ch32_666_10_ts[] = {
0X47, 0X02, 0X03, 0X13, 0XF8, 0X5A, 0XC5, 0X40, 0X26, 0XE4, 0XD0, 0XDE,
0XAD, 0XB8, 0X76, 0X89, 0X85, 0X23, 0X06, 0X04, 0X6E, 0X05, 0X8B, 0X09,
0XC0, 0X5C, 0X96, 0X4F, 0X18, 0X51, 0X41, 0XC8, 0X40, 0X9F, 0X06, 0X93,
0X38, 0XC1, 0XBB, 0X1A, 0XBC, 0XAC, 0X47, 0XFF, 0X5E, 0X54, 0XEB, 0XA7,
0X14, 0X36, 0X85, 0X8A, 0X90, 0X14, 0X17, 0XA2, 0X9D, 0XC0, 0X84, 0X56,
0XCB, 0X97, 0X78, 0XC8, 0X57, 0X15, 0X3E, 0X61, 0X6F, 0XFE, 0XC9, 0X39,
0XEF, 0XD3, 0XB6, 0X6A, 0XD2, 0XE4, 0XFB, 0X4C, 0X05, 0XF6, 0X03, 0XED,
0X50, 0XB3, 0XE7, 0X46, 0X57, 0X24, 0X71, 0X16, 0X38, 0X45, 0X53, 0X19,
0X56, 0X25, 0X3C, 0X8D, 0X4C, 0XA9, 0X28, 0X9A, 0XB2, 0X99, 0X76, 0X52,
0X28, 0XE9, 0XD6, 0XD6, 0X11, 0X94, 0X89, 0X19, 0X4D, 0XEA, 0X68, 0X76,
0X53, 0XC6, 0XAA, 0X3A, 0XD4, 0XA1, 0X25, 0XA5, 0X03, 0XB0, 0X73, 0XA0,
0XAE, 0X11, 0XC9, 0XBD, 0X37, 0X17, 0X11, 0X5F, 0X30, 0X34, 0X34, 0X0B
.....
};
unsigned int nm.ts_len = 10000000;
另外，在vim中也可以把文件转换为16进制来显示：
:%!xxd
返回正常显示：
:%!xxd -r
linux下查看二进制文件
以十六进制格式输出：
od [选项] 文件
od -d 文件 十进制输出
-o 文件 八进制输出
-x 文件 十六进制输出
xxd 文件 输出十六进制
在vi命令状态下：
:%!xxd :%!od 将当前文本转化为16进制格式
:%!xxd -c 12 每行显示12个字节
:%!xxd -r 将当前文本转化回文本格式
posted @
2016-09-18 09:38 xzc 阅读(2520) |
评论 (0) |
编辑 收藏一、IFS 介绍
Shell 脚本中有个变量叫 IFS(Internal Field Seprator) ，内部域分隔符。完整定义是The shell uses the value stored in IFS, which is the space, tab, and newline characters by default, to delimit words for the read and set commands, when parsing output from command substitution, and when performing variable substitution.
Shell 的环境变量分为 set, env 两种，其中 set 变量可以通过 export 工具导入到 env 变量中。其中，set 是显示设置shell变量，仅在本 shell 中有效；env 是显示设置用户环境变量 ，仅在当前会话中有效。换句话说，set 变量里包含了 env 变量，但 set 变量不一定都是 env 变量。这两种变量不同之处在于变量的作用域不同。显然，env 变量的作用域要大些，它可以在 subshell 中使用。
而 IFS 是一种 set 变量，当 shell 处理"命令替换"和"参数替换"时，shell 根据 IFS 的值，默认是 space, tab, newline 来拆解读入的变量，然后对特殊字符进行处理，最后重新组合赋值给该变量。
二、IFS 简单实例
1、查看变量 IFS 的值。
- $ echo $IFS
-
- $ echo "$IFS" | od -b
- 0000000 040 011 012 012
- 0000004
$ echo $IFS $ echo "$IFS" | od -b 0000000 040 011 012 012 0000004
直接输出IFS是看不到的，把它转化为二进制就可以看到了，"040"是空格，"011"是Tab，"012"是换行符"\n" 。最后一个 012 是因为 echo 默认是会换行的。
2、$* 和 $@ 的细微差别
从下面的例子中可以看出，如果是用冒号引起来，表示这个变量不用IFS替换！！所以可以看到这个变量的"原始值"。反之，如果不加引号，输出时会根据IFS的值来分割后合并输出！ $* 是按照IFS中的第一个值来确定的！下面这两个例子还有细微的差别！
- $ IFS=:;
- $ set x y z
- $ echo $*
- x y z
- $ echo "$*"
- x:y:z
- $ echo $@
- x y z
- $ echo "$@"
- x y z
$ IFS=:; $ set x y z $ echo $* x y z $ echo "$*" x:y:z $ echo $@ x y z $ echo "$@" x y z
上例 set 变量其实是3个参数，而下面这个例子实质是2个参数，即 set "x y z" 和 set x y z 是完全不同的。
- $ set "x" "y z"
- $ echo $*
- x y z
- $ echo "$*"
- x:y z
- $ echo $@
- x y z
- $ echo "$@"
- x y z
- $ echo $* |od -b
- 0000000 170 040 171 040 172 012
- 0000006
- $ echo "$*" |od -b
- 0000000 170 072 171 040 172 012
- 0000006
$ set "x" "y z" $ echo $* x y z $ echo "$*" x:y z $ echo $@ x y z $ echo "$@" x y z $ echo $* |od -b 0000000 170 040 171 040 172 012 0000006 $ echo "$*" |od -b 0000000 170 072 171 040 172 012 0000006
小结：$* 会根据 IFS 的不同来组合值，而 $@ 则会将值用" "来组合值！
3、for 循环中的奇怪现象
- $ for x in $var ;do echo $x |od -b ;done
- 0000000 012
- 0000001
- 0000000 040 141 012
- 0000003
- 0000000 142 012
- 0000002
- 0000000 012
- 0000001
- 0000000 143 012
- 0000002
$ for x in $var ;do echo $x |od -b ;done 0000000 012 0000001 0000000 040 141 012 0000003 0000000 142 012 0000002 0000000 012 0000001 0000000 143 012 0000002
先暂且不解释 for 循环的内容！看下面这个输出！IFS 的值同上！ var=": a:b::c:"，
- $ echo $var |od -b
- 0000000 040 040 141 040 142 040 040 143 012
- 0000011
- $ echo "$var" |od -b
- 0000000 072 040 141 072 142 072 072 143 072 012
- 0000012
$ echo $var |od -b 0000000 040 040 141 040 142 040 040 143 012 0000011 $ echo "$var" |od -b 0000000 072 040 141 072 142 072 072 143 072 012 0000012
"$var"的值应该没做替换，所以还是 ": a:b::c:" (注 "072" 表示冒号)，但是$var 则发生了变化！注意输出的最后一个冒号没有了，也没有替换为空格！Why？
使用 $var 时是经历了这样一个过程！首先，按照这样的规则 [变量][IFS][变量][IFS]……根据原始 var 值中所有的分割符(此处是":")划分出变量，如果IFS的值是有多个字符组成，如IFS=":;"，那么此处的[IFS]指的是IFS中的任意一个字符($* 是按第一个字符来分隔！)，如 ":" 或者 ";" ，后面不再对[IFS]做类似说明！(注：[IFS]会有多个值，多亏 #blackold 的提醒)；然后，得到类似这样的 list， "" " a" "b" "" "c" 。如果此时 echo $var，则需要在这些变量之间用空格隔开，也就是"" [space] " a" [space] "b" [space] "" [space] "c" ，忽略掉空值，最终输出是 [space][space]a[space]b[space][space]c ！
如果最后一个字符不是分隔符，如 var="a:b"，那么最后一个分隔符后的变量就是最后一个变量！
这个地方要注意下！！如果IFS就是空格，那么类似于" [space][space]a[space]b[space][space]c "会合并重复的部分，且去头空格，去尾空格，那么最终输出会变成类似 a[space]b[space]c ，所以，如果IFS是默认值，那么处理的结果就很好算出来，直接合并、忽略多余空格即可！
另外，$* 和 $@ 在函数中的处理过程是这样的(只考虑"原始值"！)！"$@"，就是像上面处理后赋值，但是 "$*" 却不一样！它的值是用分隔符(如":")而不是空格隔开！具体例子见最后一个例子！
好了，现在来解释 for 循环的内容。for 循环遍历上面这个列表就可以了，所以 for 循环的第一个输出是空！("012"是echo输出的换行符 )。。。。后面的依次类推！不信可以试试下面这个例子，结果是一样的！
- $ for x in "" " a" "b" "" "c" ;do echo $x |od -b ;done
- 0000000 012
- 0000001
- 0000000 040 141 012
- 0000003
- 0000000 012
- 0000001
- 0000000 142 012
- 0000002
- 0000000 012
- 0000001
- 0000000 143 012
- 0000002
$ for x in "" " a" "b" "" "c" ;do echo $x |od -b ;done 0000000 012 0000001 0000000 040 141 012 0000003 0000000 012 0000001 0000000 142 012 0000002 0000000 012 0000001 0000000 143 012 0000002
三、IFS的其他实例
Example 1:
- $ IFS=:
- $ var=ab::cd
- $ echo $var
- ab cd
- $ echo "$var"
- ab::cd
$ IFS=: $ var=ab::cd $ echo $var ab cd $ echo "$var" ab::cd
解释下：x 的值是 "ab::cd"，当进行到 echo $x 时，因为$符，所以会进行变量替换。Shell 根据 IFS 的值将 x 分解为 ab "" cd，然后echo，插入空隔，ab[space]""[space]cd，忽略""，输出 ab cd 。
Example 2 :
- $ read a
- xy z
- $ echo $a
- xy z
$ read a xy z $ echo $a xy z
解释：这是 http://bbs.chinaunix.net/thread-207178-1-1.html 上的一个例子。此时IFS是默认值，本希望把所有的输入(包括空格)都放入变量a中，但是输出的a却把前面的空格给忽略了！！原因是：默认的 IFS 会按 space tab newline 来分割。这里需要注意的一点是，read 命令的实现过程，即在读入时已经替换了。解决办法是在开头加上一句 IFS=";" ，这里必须加上双引号，因为分号有特殊含义。
Example 3 :
- $ tmp=" xy z"
- $ a=$tmp
- $ echo $a
- $ echo "$a"
$ tmp=" xy z" $ a=$tmp $ echo $a $ echo "$a"
解释：什么时候会根据 IFS 来"处理"呢？我觉得是，对于不加引号的变量，使用时都会参考IFS，但是要注意其原始值！
Example 4 ：
- #!/bin/bash
- IFS_old=$IFS #将原IFS值保存，以便用完后恢复
- IFS=$’\n’ #更改IFS值为$’\n’ ，注意，以回车做为分隔符，IFS必须为：$’\n’
- for i in $((cat pwd.txt)) #pwd.txt 来自这个命令：cat /etc/passwd >pwd.txt
- do
- echo $i
- done
- IFS=$IFS_old #恢复原IFS值
#!/bin/bash IFS_old=$IFS #将原IFS值保存，以便用完后恢复 IFS=$’\n’ #更改IFS值为$’\n’ ，注意，以回车做为分隔符，IFS必须为：$’\n’ for i in $((cat pwd.txt)) #pwd.txt 来自这个命令：cat /etc/passwd >pwd.txt do echo $i done IFS=$IFS_old #恢复原IFS值
另外一个例子，把IP地址逆转输出：
Example 5 :
- #!/bin/bash
-
- IP=220.112.253.111
- IFS="."
- TMPIP=$(echo $IP)
- IFS=" " # space
- echo $TMPIP
- for x in $TMPIP ;do
- Xip="${x}.$Xip"
- done
- echo ${Xip%.}
#!/bin/bash IP=220.112.253.111 IFS="." TMPIP=$(echo $IP) IFS=" " # space echo $TMPIP for x in $TMPIP ;do Xip="${x}.$Xip" done echo ${Xip%.}Complex_Example 1: http://bbs.chinaunix.net/forum.php?mod=viewthread&tid=3660898&page=1#pid21798049
- function output_args_ifs(){
- echo "=$*"
- echo "="$*
- for m in $* ;do
- echo "[$m]"
- done
- }
-
- IFS=':'
- var='::a:b::c:::'
- output_args_ifs $var
function output_args_ifs(){ echo "=$*" echo "="$* for m in $* ;do echo "[$m]" done } IFS=':' var='::a:b::c:::' output_args_ifs $var
输出为：
- =::a:b::c:: # 少了最后一个冒号！看前面就知道为什么了
- = a b c
- []
- []
- [a]
- [b]
- []
- [c]
- []
=::a:b::c:: # 少了最后一个冒号！看前面就知道为什么了 = a b c [] [] [a] [b] [] [c] []
由于 "output_args_ifs $var" 中 $var 没有加引号，所以根据IFS替换！根据IFS划分出变量： "" "" "a" "b" "" "c" "" ""(可以通过输出 $# 来测试参数的个数！)，重组的结果为
"$@" 的值是 "" [space] "" [space] "a" [space] "b" [space] "" [space] "c" [space] "" [space] ""，可以通过，echo==>" a b c "
"$*" 的值是 "" [IFS] "" [IFS] "a" [IFS] "b" [IFS] "" [IFS] "c" [IFS] "" [IFS] ""，忽略""，echo=>"::a:b::c::"
注意， $* 和 $@ 的值都是 "" "" "a" "b" "" "c" "" "" 。可以说是一个列表……因为他们本来就是由 $1 $2 $3……组成的。
所以，《Linux程序设计》里推荐使用 $@，而不是$*
总结：IFS 其实还是很麻烦的，稍有不慎就会产生很奇怪的结果，因此使用的时候要注意！我也走了不少弯路，只希望能给后来者一些帮助。本文若有问题，欢迎指正！！谢谢！
如有转载，请注明blog.csdn.net/whuslei
参考：
http://blog.chinaunix.net/space.php?uid=20543672&do=blog&id=94358
http://smilejay.com/2011/12/bash_ifs/#comment-51
posted @
2016-04-01 15:00 xzc 阅读(273) |
评论 (1) |
编辑 收藏