crontab v1.0.0

2. TODO: 完善主框架之间的连用

crontab.go

@@ -0,0 +1,410 @@
+package curl2info
+
+import (
+	"errors"
+	"fmt"
+	"log"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/Pallinder/go-randomdata"
+
+	"github.com/davecgh/go-spew/spew"
+)
+
+type randLR struct {
+	left, right int
+}
+
+type hInterval struct {
+	PlanFail   []randLR
+	PlanNormal []randLR
+
+	Count      int
+	ConstCount int
+}
+
+func (interval *hInterval) reset() {
+	interval.Count = interval.ConstCount
+}
+
+type timePointer struct {
+	left, right           int
+	leftlimit, rightlimit int
+	per                   int
+	isAll                 bool
+}
+
+func (tp *timePointer) String() string {
+	return fmt.Sprintf("left: %d, right: %d, leftlimit: %d, rightlimit: %d, per: %d", tp.left, tp.right, tp.leftlimit, tp.rightlimit, tp.per)
+}
+
+// Crontab 的string解析
+type Crontab struct {
+	min   []timePointer
+	hour  []timePointer
+	day   []timePointer
+	month []timePointer
+	week  []timePointer
+
+	WillPlans []time.Time
+	SkipPlans []time.Time
+
+	YearPlan *trieYear
+
+	interval   *CircularLinked
+	lastStatus bool
+	nextTime   time.Time
+}
+
+// NewCrontab create 一个crontab
+func NewCrontab(crontab string) *Crontab {
+	cron := &Crontab{}
+	cron.FromString(crontab)
+	return cron
+}
+
+// SetStatus 设置状态 接口定义
+func (cron *Crontab) SetStatus(status interface{}) {
+	if cron.interval != nil {
+		cron.lastStatus = status.(bool)
+	}
+}
+
+// GetStatus 设置状态 接口定义
+func (cron *Crontab) GetStatus() (status interface{}) {
+	if cron.interval != nil {
+		return cron.lastStatus
+	}
+	return nil
+}
+
+// TimeUp 是否时间快到
+func (cron *Crontab) TimeUp() bool {
+
+	if cron.interval != nil {
+		return cron.intervalTimeUp()
+	}
+
+	return cron.linuxTimeUp()
+}
+
+// NextTime 返回下次任务的时间
+func (cron *Crontab) NextTime() *time.Time {
+	if cron.interval != nil {
+		return &cron.nextTime
+	}
+
+	if len(cron.WillPlans) > 0 {
+		return &cron.WillPlans[0]
+	}
+
+	return nil
+}
+
+func (cron *Crontab) String() string {
+	return fmt.Sprintf("min:%s\nhour:%s\nday:%s\nmonth:%s\nweek:%s\n", spew.Sdump(cron.min), spew.Sdump(cron.hour), spew.Sdump(cron.day), spew.Sdump(cron.month), spew.Sdump(cron.week))
+}
+
+// FromString 解析crontab 的 表达式
+func (cron *Crontab) FromString(crontab string) error {
+	crontab = strings.TrimSpace(crontab)
+
+	matches := regexp.MustCompile("[^ ]+").FindAllString(crontab, -1)
+	mlen := len(matches)
+	switch mlen {
+	case 1:
+		// "f1-2|5-10x5,f1|10m,10-15,f1"
+		cron.nextTime = time.Now()
+		cron.lastStatus = true
+		cron.interval = NewCircularLinked()
+		var intervalList []interface{}
+		intervalList = parseIntervalString(matches[0])
+		cron.interval.Append(intervalList...)
+
+	case 5:
+		cron.min = createTimePointer(matches[0], 0, 59, true)
+		cron.hour = createTimePointer(matches[1], 0, 23, true)
+		cron.day = createTimePointer(matches[2], 1, 31, false)
+		cron.month = createTimePointer(matches[3], 1, 12, true)
+		cron.week = createTimePointer(matches[4], 0, 6, true)
+
+		cron.createYearPlan()
+	default:
+		return errors.New("mathches len != want, check crontab string")
+	}
+
+	return nil
+}
+
+// createYearPlan 创建年度计划
+func (cron *Crontab) createYearPlan() {
+	cron.YearPlan = newTrieYear()
+	cron.YearPlan.FromCrontab(cron)
+}
+
+func (cron *Crontab) linuxTimeUp() bool {
+	now := time.Now()
+	maxlen := 1000
+	createlen := 500
+
+	plen := len(cron.WillPlans)
+	if plen <= createlen {
+		var lastplan time.Time
+		if plen == 0 {
+			lastplan = now
+		} else {
+			lastplan = cron.WillPlans[plen-1].Add(time.Minute)
+		}
+		if !cron.YearPlan.CheckYear() {
+			cron.createYearPlan()
+		}
+
+		timeplans := cron.YearPlan.GetPlanTime(cron, lastplan, uint(maxlen-plen))
+		cron.WillPlans = append(cron.WillPlans, timeplans...)
+	}
+
+	if len(cron.WillPlans) > 0 {
+		istimeup := false
+		for i := 0; i < maxlen; i++ {
+			if now.Unix() >= cron.WillPlans[i].Unix() {
+				istimeup = true
+			} else {
+				if istimeup {
+					if i-1 > 0 {
+						cron.SkipPlans = append(cron.SkipPlans, cron.WillPlans[0:i-1]...)
+						if len(cron.SkipPlans) >= maxlen+200 {
+							cron.SkipPlans = cron.SkipPlans[200:]
+						}
+					}
+					cron.WillPlans = cron.WillPlans[i:]
+					return istimeup
+				}
+
+				return istimeup
+			}
+		}
+
+		cron.SkipPlans = append(cron.SkipPlans, cron.WillPlans...)
+		cron.WillPlans = nil
+		return istimeup
+	}
+
+	log.Panicln("error willplans range")
+	return false
+}
+
+func (cron *Crontab) intervalTimeUp() bool {
+
+	now := time.Now()
+	if now.Unix() >= cron.nextTime.Unix() {
+
+		iv := cron.interval.Cursor().GetValue().(hInterval)
+		isecond := 0
+		if cron.lastStatus == false && len(iv.PlanFail) > 0 {
+			idx := randomdata.Number(len(iv.PlanFail))
+			lr := iv.PlanFail[idx]
+			isecond = randomdata.Number(lr.left, lr.right+1)
+		} else {
+			idx := randomdata.Number(len(iv.PlanNormal))
+			lr := iv.PlanNormal[idx]
+			isecond = randomdata.Number(lr.left, lr.right+1)
+		}
+
+		iv.Count--
+		if iv.Count <= 0 {
+			iv.reset()
+			cron.interval.MoveNext()
+		}
+
+		cron.nextTime = now.Add(time.Duration(isecond) * time.Second)
+		return true
+	}
+
+	return false
+}
+
+func createTimePointer(min string, llimit, rlimit int, fixedLeftRight bool) []timePointer {
+
+	var result []timePointer
+
+	exelist := strings.Split(min, ",")
+	for _, exe := range exelist {
+		tp := timePointer{}
+
+		takeper := strings.Split(exe, "/") // per
+		var rangevalue, per string
+		if len(takeper) == 1 {
+			rangevalue = exe
+			per = "1"
+		} else {
+			rangevalue = takeper[0]
+			per = takeper[1]
+		}
+		// takeRange
+		be := strings.Split(rangevalue, "-")
+		var left, rigth string
+		switch len(be) {
+		case 1:
+			left = be[0]
+			rigth = be[0]
+		case 2:
+			left = be[0]
+			rigth = be[1]
+		default:
+			panic(errors.New("range value is > 2"))
+		}
+
+		if left == "*" {
+			tp.left = llimit
+		} else {
+			ileft, err := strconv.Atoi(strings.Replace(left, "^", "-", -1))
+			if err != nil {
+				panic(err)
+			}
+			tp.left = ileft
+		}
+
+		if rigth == "*" {
+			tp.right = rlimit
+		} else {
+			iright, err := strconv.Atoi(strings.Replace(rigth, "^", "-", -1))
+			if err != nil {
+				panic(err)
+			}
+			tp.right = iright
+		}
+
+		iper, err := strconv.Atoi(per)
+		if err != nil {
+			panic(err)
+		}
+
+		tp.per = iper
+		tp.leftlimit = llimit
+		tp.rightlimit = rlimit
+
+		// 修正左值
+		leftfixed := tp.left
+		if leftfixed < 0 {
+			leftfixed += tp.rightlimit + 1
+			if fixedLeftRight {
+				tp.left = leftfixed
+			}
+		}
+
+		rightfixed := tp.right
+		if rightfixed < 0 {
+			rightfixed += tp.rightlimit + 1
+			if fixedLeftRight {
+				tp.right = rightfixed
+			}
+		}
+
+		// 全部符合 当左等于左 且 右等于右最大 并且 per == 1 TODO: 如果加入时间间隔 就需要 加多一个 附加值
+		if leftfixed == tp.leftlimit && rightfixed == tp.rightlimit && tp.per == 1 {
+			tp.isAll = true
+		}
+
+		result = append(result, tp)
+	}
+
+	return result
+}
+
+func parseIntervalString(crontab string) []interface{} {
+	var result []interface{}
+
+	values := strings.Split(crontab, ",")
+	for _, value := range values {
+		interval := hInterval{}
+		// 次数
+		valuesCounts := strings.Split(value, "x")
+		switch len(valuesCounts) {
+		case 1:
+			interval.ConstCount = 1
+
+		case 2:
+			count, err := strconv.Atoi(valuesCounts[1])
+			if err != nil {
+				panic(err)
+			}
+			interval.ConstCount = count
+		default:
+			panic("valuesCounts error, the len is not in range")
+		}
+
+		// 统计失败与普通间隔值的数组
+		failAndNormal := valuesCounts[0]
+
+		valuesFN := strings.Split(failAndNormal, "|")
+
+		for _, FN := range valuesFN {
+			if FN == "" {
+				continue
+			}
+
+			switch FN[0] {
+			case 'f', 'F':
+				fvalue := FN[1:]
+				interval.PlanFail = append(interval.PlanFail, parseRandLR(fvalue))
+			case 'n':
+				value := FN[1:]
+				interval.PlanNormal = append(interval.PlanNormal, parseRandLR(value))
+			default:
+				interval.PlanNormal = append(interval.PlanNormal, parseRandLR(FN))
+			}
+		}
+
+		interval.reset()
+		result = append(result, interval)
+	}
+
+	return result
+}
+
+func parseRandLR(value string) randLR {
+	vlen := len(value)
+	lastchar := value[vlen-1]
+
+	lr := strings.Split(value, "-")
+	switch len(lr) {
+	case 1:
+		lr := randLR{parseTimeValue(lr[0], lastchar), parseTimeValue(lr[0], lastchar)}
+		return lr
+	case 2:
+
+		lr := randLR{parseTimeValue(lr[0], lastchar), parseTimeValue(lr[1], lastchar)}
+		return lr
+	default:
+		panic("lr is error")
+	}
+}
+
+func getInt(v string) int {
+	vint, err := strconv.Atoi(v)
+	if err != nil {
+		panic(err)
+	}
+	return vint
+}
+
+func parseTimeValue(v string, lastchar byte) int {
+
+	vlen := len(v)
+
+	switch lastchar {
+	case 's':
+		return getInt(v[:vlen-1])
+	case 'm':
+		return getInt(v[:vlen-1]) * 60
+	case 'h':
+		return getInt(v[:vlen-1]) * 3600
+	case 'd':
+		return getInt(v[:vlen-1]) * 3600 * 24
+	default:
+		return getInt(v)
+	}
+}

crontab_test.go

@@ -0,0 +1,75 @@
+package curl2info
+
+import (
+	"fmt"
+	"runtime"
+	"testing"
+	"time"
+)
+
+// type LRValue struct {
+// 	left, right int
+// }
+
+func TestParseCrontab(t *testing.T) {
+	// crontab := "0-5/2,7-30/3,30,35,40-^1 * * * *" //(秒) 分 时 号(每月的多少号, 要注意月可可能性)  星期几(每个星期的) /每 ,列表 -范围
+	crontab := "* * * * *"
+
+	PrintMemUsage()
+
+	ty := newTrieYear()
+	cron := NewCrontab(crontab)
+	ty.FromCrontab(cron)
+
+	if len(ty.GetPlanTime(cron, time.Now(), 10)) != 10 {
+		t.Error("GetPlanTime error len != 10")
+	}
+
+	cron.createYearPlan()
+	if !cron.TimeUp() {
+		t.Error("timeup error")
+	}
+
+	PrintMemUsage()
+
+}
+
+func TestParseInterval(t *testing.T) {
+	// crontab := "0-5/2,7-30/3,30,35,40-^1 * * * *" //(秒) 分 时 号(每月的多少号, 要注意月可可能性)  星期几(每个星期的) /每 ,列表 -范围
+	// t.Error("")
+	// crontab := "f1-2|1-3|5-8x5,f1|10m,10-15,f1"
+
+	// PrintMemUsage()
+	// cron := NewCrontab(crontab)
+
+	// now := time.Now()
+	// for i := 0; i <= 15; i++ {
+	// 	if cron.TimeUp() {
+	// 		log.Println(time.Since(now))
+	// 		now = time.Now()
+	// 	}
+	// 	time.Sleep(time.Second)
+	// }
+
+	// PrintMemUsage()
+}
+
+func TestCrontabPlus(t *testing.T) {
+	// crontab := "0-5/2,7-30/3,30,35,40-^1 * * * *" //(秒) 分 时 号(每月的多少号, 要注意月可可能性)  星期几(每个星期的) /每 ,列表 -范围
+	// crondata := NewCrontab("*22 * * * *")
+
+}
+
+func PrintMemUsage() {
+	var m runtime.MemStats
+	runtime.ReadMemStats(&m)
+	// For info on each, see: https://golang.org/pkg/runtime/#MemStats
+	fmt.Printf("Alloc = %v MiB", bToMb(m.Alloc))
+	fmt.Printf("\tTotalAlloc = %v MiB", bToMb(m.TotalAlloc))
+	fmt.Printf("\tSys = %v MiB", bToMb(m.Sys))
+	fmt.Printf("\tNumGC = %v\n", m.NumGC)
+}
+
+func bToMb(b uint64) uint64 {
+	return b / 1024 / 1024
+}

option.go

@@ -30,10 +30,12 @@ func init() {
 		//"--"
 		{"--header", 10, parseHeader, nil},
 		{"--insecure", 15, parseInsecure, nil},
-		{"--task", 10, parseITask, &extract{re: "--task +(.+)", execute: extractData}},
 		{"--user-agent", 15, parseUserAgent, &extract{re: "--user-agent +(.+)", execute: extractData}},
 		{"--user", 15, parseUser, &extract{re: "--user +(.+)", execute: extractData}},
 		{"--connect-timeout", 15, parseTimeout, &extract{re: "--connect-timeout +(.+)", execute: extractData}},
+		// 自定义
+		{"--task", 10, parseITask, &extract{re: "--task +(.+)", execute: extractData}},
+		{"--crontab", 10, parseCrontab, &extract{re: "--crontab +(.+)", execute: extractData}},
 	}
 
 	for _, oe := range oelist {
@@ -93,6 +95,10 @@ func extractData(re, soption string) string {
 	return strings.Trim(datas[1], "'")
 }
 
+func parseCrontab(u *CURL, value string) {
+
+}
+
 func parseITask(u *CURL, value string) {
 	u.ITask = value
 }

parse_curl.go

@@ -117,7 +117,14 @@ func ParseRawCURL(scurl string) (cURL *CURL, err error) {
 	scurl = strings.TrimSpace(scurl)
 	scurl = strings.TrimLeft(scurl, "curl")
 
-	mathches := regexp.MustCompile(`--[^ ]+ +'[^']+'|--[^ ]+ +[^ ]+|-[A-Za-z] +'[^']+'|-[A-Za-z] +[^ ]+| '[^']+'|--[a-z]+ {0,}`).FindAllString(scurl, -1)
+	mathches := regexp.MustCompile(
+		`--[^ ]+ +'[^']+'|`+
+			`--[^ ]+ +[^ ]+|`+
+			`-[A-Za-z] +'[^']+'|`+
+			`-[A-Za-z] +[^ ]+|`+
+			` '[^']+'|`+
+			`--[a-z]+ {0,}`,
+	).FindAllString(scurl, -1)
 	for _, m := range mathches {
 		m = strings.TrimSpace(m)
 		switch v := m[0]; v {

structure.go

@@ -1,6 +1,12 @@
 package curl2info
 
-import "container/heap"
+import (
+	"container/heap"
+	"log"
+	"strings"
+
+	"github.com/davecgh/go-spew/spew"
+)
 
 // trieWord Trie 需要的Word接口
 type trieWord interface {
@@ -242,3 +248,234 @@ func (pqe *pQueueExecute) Len() int {
 // 	}
 // 	return content
 // }
+
+// CNode 循环链表 三色标记 不确定是否会清除循环引用, 网上说会
+type CNode struct {
+	value interface{}
+	prev  *CNode
+	next  *CNode
+}
+
+// GetValue 获取到Node的值
+func (node *CNode) GetValue() interface{} {
+	return node.value
+}
+
+// SetValue 获取到Node的值
+func (node *CNode) SetValue(value interface{}) {
+	node.value = value
+}
+
+// CircularLinked 循环链表
+type CircularLinked struct {
+	cursor *CNode
+	head   *CNode
+	tail   *CNode
+	size   uint64
+}
+
+// NewCircularLinked create a CircularLinked
+func NewCircularLinked(values ...interface{}) *CircularLinked {
+	list := &CircularLinked{}
+	if len(values) > 0 {
+		list.Append(values...)
+	}
+	return list
+}
+
+// Cursor get current Cursor
+func (list *CircularLinked) Cursor() *CNode {
+	if list.cursor == nil {
+		list.cursor = list.head
+	}
+	return list.cursor
+}
+
+// MoveNext get next Cursor
+func (list *CircularLinked) MoveNext() *CNode {
+	if list.cursor == nil {
+		list.cursor = list.head
+	}
+	list.cursor = list.cursor.next
+	return list.cursor
+}
+
+// MovePrev get prev Cursor
+func (list *CircularLinked) MovePrev() *CNode {
+	if list.cursor == nil {
+		list.cursor = list.head
+	}
+	list.cursor = list.cursor.prev
+	return list.cursor
+}
+
+// CursorToHead cursor move to head
+func (list *CircularLinked) CursorToHead() *CNode {
+	list.cursor = list.head
+	return list.cursor
+}
+
+// CursorToTail cursor move to tail
+func (list *CircularLinked) CursorToTail() *CNode {
+	list.cursor = list.tail
+	return list.cursor
+}
+
+// GetLoopValues 获取从头到尾的值
+func (list *CircularLinked) GetLoopValues() []*CNode {
+	var result []*CNode
+
+	if list.head != nil {
+		result = append(result, list.head)
+		for cur := list.head.next; cur != list.head; cur = cur.next {
+			result = append(result, cur)
+		}
+	}
+	return result
+}
+
+// Append a value (one or more) at the end of the list (same as Append())
+func (list *CircularLinked) Append(values ...interface{}) {
+	for _, value := range values {
+		node := &CNode{value: value}
+		if list.size == 0 {
+			list.head = node
+			list.tail = node
+			node.next = node
+			node.prev = node
+		} else {
+			list.tail.next = node
+			node.next = list.head
+			node.prev = list.tail
+			list.tail = node
+		}
+		list.size++
+	}
+}
+
+// Remove 移除一些节点
+func (list *CircularLinked) Remove(node *CNode) {
+
+	switch list.size {
+	case 0:
+		list.errorNotInList(node)
+	case 1:
+		if list.head == node {
+			list.head = nil
+			list.tail = nil
+			node.next = nil
+			node.prev = nil
+			list.cursor = nil
+			list.size--
+		} else {
+			list.errorNotInList(node)
+		}
+	case 2:
+
+		node.prev = nil
+		node.next = nil
+
+		switch node {
+		case list.head:
+			list.head = list.tail
+			list.tail.prev = list.head
+			list.head.next = list.tail
+			list.cursor = list.head
+			list.size--
+		case list.tail:
+			list.tail = list.head
+			list.tail.prev = list.head
+			list.head.next = list.tail
+			list.cursor = list.head
+			list.size--
+		default:
+			list.errorNotInList(node)
+		}
+
+	default:
+		switch node {
+		case list.head:
+			_, next := list.cutAndSplice(node)
+			list.size--
+			list.head = next
+			if list.cursor == node {
+				list.cursor = next
+			}
+		case list.tail:
+			prev, _ := list.cutAndSplice(node)
+			list.size--
+			list.tail = prev
+			if list.cursor == node {
+				list.cursor = prev
+			}
+		default:
+			_, next := list.cutAndSplice(node)
+			list.size--
+			if list.cursor == node {
+				list.cursor = next
+			}
+		}
+	}
+
+}
+
+// LookCursor for list show
+func (list *CircularLinked) LookCursor() string {
+	cursor := list.Cursor()
+
+	content := "->["
+	cur := list.head
+	if list.size != 0 {
+		for size := uint64(0); size < list.size; size++ {
+			if cursor == cur {
+				content += "(" + spew.Sprint(cur.value) + ")" + ", "
+			} else {
+				content += spew.Sprint(cur.value) + ", "
+			}
+
+			cur = cur.next
+		}
+	}
+	content = strings.TrimRight(content, ", ")
+	showlen := len(content)
+	if showlen >= 64 {
+		showlen = 64
+	}
+	content += "]" + content[0:showlen] + " ..."
+	return content
+}
+
+// Clear for list show
+func (list *CircularLinked) Clear() {
+	if list.size != 0 {
+		list.head.prev = nil
+		list.tail.next = nil
+		list.head = nil
+		list.tail = nil
+		list.cursor = nil
+		list.size = 0
+	}
+}
+
+// Size for list show
+func (list *CircularLinked) Size() uint64 {
+	return list.size
+}
+
+func (list *CircularLinked) errorNotInList(node *CNode) {
+	log.Println("the node value ", spew.Sprint(node), " is not in list")
+}
+
+// cutAndSplice 不考虑边界情况 上层使用的是否判断
+func (list *CircularLinked) cutAndSplice(node *CNode) (prev, next *CNode) {
+	prev = node.prev
+	next = node.next
+
+	prev.next = next
+	next.prev = prev
+
+	node.prev = nil
+	node.next = nil
+
+	return prev, next
+}

trie_year.go

@@ -0,0 +1,269 @@
+package curl2info
+
+import (
+	"time"
+)
+
+type minuteNode struct {
+}
+
+func newMinuteNode() *minuteNode {
+	return &minuteNode{}
+}
+
+type hourNode struct {
+	Minute [60]*minuteNode
+}
+
+func (hour *hourNode) CreateMinute(nminute int) {
+	min := &minuteNode{}
+	hour.Minute[nminute] = min
+}
+
+func newHourNode() *hourNode {
+	return &hourNode{}
+}
+
+type dayNode struct {
+	IsClear bool
+	Week    time.Weekday
+	Hour    [24]*hourNode
+}
+
+func (day *dayNode) CreateHour(nhour int) {
+	hour := &hourNode{}
+	day.Hour[nhour] = hour
+}
+
+func newDayNode(curday *time.Time) *dayNode {
+	day := &dayNode{}
+
+	week := curday.Weekday()
+	day.Week = week
+	day.IsClear = true
+
+	return day
+}
+
+type monthNode struct {
+	MaxDay int
+	First  *time.Time
+	Day    [32]*dayNode
+}
+
+func (month *monthNode) CreateDay(nday int) {
+	day := month.First.AddDate(0, 0, nday-1)
+	month.Day[nday] = newDayNode(&day)
+}
+
+func newMonthNode(year, month int) *monthNode {
+	Month := &monthNode{}
+	First := time.Date(year, time.Month(month), 1, 0, 0, 0, 0, time.Local)
+	Month.First = &First
+	Month.MaxDay = Month.First.AddDate(0, 1, -1).Day()
+	return Month
+}
+
+type trieYear struct {
+	Year  int
+	Month [13]*monthNode
+}
+
+// CheckYear 跨年判断
+func (ty *trieYear) CheckYear() bool {
+	year := time.Now().Year()
+	return ty.Year == year
+}
+
+func (ty *trieYear) clearHour() {
+
+	for _, month := range ty.Month {
+		if month != nil {
+			for _, day := range month.Day {
+				if day != nil {
+					for i := 0; i <= 23; i++ {
+						day.Hour[i] = nil
+						day.IsClear = true
+					}
+				}
+
+			}
+		}
+
+	}
+
+}
+
+func newTrieYear() *trieYear {
+	ty := trieYear{}
+	ty.Year = time.Now().Year()
+	return &ty
+}
+
+// GetPlanTime 获取计划表
+func (ty *trieYear) GetPlanTime(cron *Crontab, aftertime time.Time, count uint) []time.Time {
+
+	now := aftertime
+	nmonth := int(now.Month())
+	nday := now.Day()
+	nhour := now.Hour()
+	nminute := now.Minute()
+
+	var result []time.Time
+
+	for i := 1; i <= 12; i++ {
+
+		if i < nmonth {
+			continue
+		}
+
+		month := ty.Month[i]
+		if month != nil {
+
+			for j := 1; j <= 31; j++ {
+
+				if nmonth == i {
+					if j < nday {
+						continue
+					}
+				}
+
+				day := month.Day[j]
+				if day != nil {
+
+					if day.IsClear {
+						insertHour(cron, day)
+					}
+
+					for k := 0; k <= 23; k++ {
+
+						if nmonth == i && nday == j {
+							if k < nhour {
+								continue
+							}
+						}
+
+						hour := day.Hour[k]
+
+						if hour != nil {
+
+							for n := 0; n <= 59; n++ {
+								if nmonth == i && nday == j && nhour == k {
+									if n < nminute {
+										continue
+									}
+								}
+
+								min := hour.Minute[n]
+								if min != nil {
+
+									curTime := time.Date(ty.Year, time.Month(i), j, k, n, 0, 0, time.Local)
+									result = append(result, curTime)
+									count--
+									if count <= 0 {
+										ty.clearHour()
+										return result
+									}
+								}
+							}
+
+						}
+					}
+
+				}
+			}
+		}
+	}
+
+	ty.clearHour()
+	return result
+}
+
+// FromCrontab 从Crontab生成树
+func (ty *trieYear) FromCrontab(cron *Crontab) {
+	// 月的填充
+	for _, month := range cron.month {
+
+		left := month.left
+		right := month.right
+
+		for i := left; i <= right; i += month.per {
+			curMonth := newMonthNode(ty.Year, i)
+			ty.Month[i] = curMonth
+			// 天的填充
+			insertDay(cron, curMonth)
+		}
+	}
+}
+
+func filterDay(cron *Crontab, curday *dayNode) bool {
+
+	for _, w := range cron.week {
+		if w.isAll {
+			return false
+		}
+
+		for n := w.left; n <= w.right; n += w.per {
+			if n == int(curday.Week) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func insertDay(cron *Crontab, curMonth *monthNode) {
+	for _, day := range cron.day {
+
+		left := day.left
+		if left < 0 {
+			left += curMonth.MaxDay + 1
+		}
+
+		right := day.right
+		if right < 0 {
+			right += curMonth.MaxDay + 1
+		}
+
+		for j := left; j <= right; j += day.per {
+			curMonth.CreateDay(j)
+			curDay := curMonth.Day[j]
+
+			if filterDay(cron, curDay) {
+				curMonth.Day[j] = nil
+			} else {
+				// insertHour(cron, curDay)
+			}
+		}
+
+	}
+}
+
+func insertHour(cron *Crontab, curDay *dayNode) {
+	curDay.IsClear = false
+	// 时的填充
+	for _, hour := range cron.hour {
+
+		left := hour.left
+		right := hour.right
+
+		for k := left; k <= right; k += hour.per {
+			curDay.CreateHour(k)
+			curHour := curDay.Hour[k]
+			insertMinute(cron, curHour)
+		}
+	}
+}
+
+func insertMinute(cron *Crontab, curHour *hourNode) {
+	for _, min := range cron.min {
+
+		left := min.left
+		right := min.right
+
+		for l := left; l <= right; l += min.per {
+			curHour.CreateMinute(l)
+		}
+
+	}
+}