summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--lib/blink/client.rb4
-rw-r--r--lib/blink/transportable.rb18
-rw-r--r--lib/blink/type.rb48
-rw-r--r--lib/blink/type/component.rb1
-rw-r--r--lib/blink/type/typegen.rb43
-rw-r--r--lib/blink/type/typegen/filerecord.rb81
-rw-r--r--lib/blink/type/typegen/filetype.rb41
7 files changed, 164 insertions, 72 deletions
diff --git a/lib/blink/client.rb b/lib/blink/client.rb
index 1715ab8f5..ea5c449d4 100644
--- a/lib/blink/client.rb
+++ b/lib/blink/client.rb
@@ -22,6 +22,8 @@ module Blink
class Client < SOAP::RPC::HTTPServer
def initialize(hash)
# to whom do we connect?
+ @server = nil
+ @nil = nil
@url = hash[:Server]
if hash.include?(:Listen) and hash[:Listen] == false
Blink.notice "We're local"
@@ -61,9 +63,7 @@ module Blink
# manipulations
def config(tree)
Blink.notice("Calling config")
- Blink.verbose tree.inspect
container = Marshal::load(tree).to_type
- #Blink.verbose container.inspect
# for now we just evaluate the top-level container, but eventually
# there will be schedules and such associated with each object,
diff --git a/lib/blink/transportable.rb b/lib/blink/transportable.rb
index 48dee6423..afb6f8061 100644
--- a/lib/blink/transportable.rb
+++ b/lib/blink/transportable.rb
@@ -54,16 +54,17 @@ module Blink
self[namevar] = self[:name]
self.delete(:name)
end
- begin
+ p self
+ #begin
# this will fail if the type already exists
# which may or may not be a good thing...
retobj = type.new(self)
- rescue => detail
- Blink.error "Failed to create object: %s" % detail
- #puts object.class
- #puts object.inspect
- #exit
- end
+ #rescue => detail
+ # Blink.error "Failed to create %s: %s" % [type.name,detail]
+ # puts self.class
+ # puts self.inspect
+ # exit
+ #end
else
raise "Could not find object type %s" % self.type
end
@@ -125,7 +126,7 @@ module Blink
# exists in our scope
# this assumes that type/name combinations are globally
# unique
- name = [child[:name],child[:type]].join("--")
+ name = [child[:name],child.type].join("--")
if nametable.include?(name)
object = nametable[name]
@@ -133,6 +134,7 @@ module Blink
# don't rename; this shouldn't be possible anyway
next if var == :name
+ Blink.notice "Adding %s to %s" % [var,name]
# override any existing values
object[var] = value
}
diff --git a/lib/blink/type.rb b/lib/blink/type.rb
index 7ca72c5c1..1b7f0e252 100644
--- a/lib/blink/type.rb
+++ b/lib/blink/type.rb
@@ -133,7 +133,7 @@ class Blink::Type < Blink::Element
def Type.inherited(sub)
sub.initvars
- Blink.debug("subtype %s just created" % sub)
+ #Blink.notice("subtype %s(%s) just created" % [sub,sub.superclass])
# add it to the master list
# unfortunately we can't yet call sub.name, because the #inherited
# method gets called before any commands in the class definition
@@ -148,8 +148,13 @@ class Blink::Type < Blink::Element
def Type.initvars
@objects = Hash.new
@actions = Hash.new
+ #Blink.verbose "initing validstates for %s" % self
@validstates = {}
@validparameters = {}
+
+ unless defined? @states
+ @states = {}
+ end
end
#---------------------------------------------------------------
@@ -280,12 +285,32 @@ class Blink::Type < Blink::Element
#---------------------------------------------------------------
#---------------------------------------------------------------
+ # this is probably only used by FileRecord objects
+ def Type.parameters=(params)
+ Blink.notice "setting parameters to [%s]" % params.join(" ")
+ @parameters = params.collect { |param|
+ if param.class == Symbol
+ param
+ else
+ param.intern
+ end
+ }
+ end
+ #---------------------------------------------------------------
+
+ #---------------------------------------------------------------
def Type.states
return @states
end
#---------------------------------------------------------------
#---------------------------------------------------------------
+ def Type.validstates
+ return @validstates
+ end
+ #---------------------------------------------------------------
+
+ #---------------------------------------------------------------
def Type.validstate(name)
unless @validstates.length == @states.length
self.buildstatehash
@@ -396,6 +421,14 @@ class Blink::Type < Blink::Element
@notify = Hash.new
@actions = Hash.new
+ # convert all strings to symbols
+ hash.each { |var,value|
+ unless var.is_a? Symbol
+ hash[var.intern] = value
+ hash.delete(var)
+ end
+ }
+
# if they passed in a list of states they're interested in,
# we mark them as "interesting"
# XXX maybe we should just consider params set to nil as 'interesting'
@@ -408,9 +441,9 @@ class Blink::Type < Blink::Element
hash.delete(:check)
end
- if hash.include?("noop")
- @noop = hash["noop"]
- hash.delete("noop")
+ if hash.include?(:noop)
+ @noop = hash[:noop]
+ hash.delete(:noop)
end
# states and parameters are treated equivalently from the outside:
@@ -523,6 +556,10 @@ class Blink::Type < Blink::Element
# this returns any changes resulting from testing, thus 'collect'
# rather than 'each'
def evaluate
+ unless defined? @evalcount
+ Blink.error "No evalcount defined on '%s' of type '%s'" %
+ [self.name,self.class]
+ end
# if we're a metaclass and we've already evaluated once...
if self.metaclass and @evalcount > 0
return
@@ -596,3 +633,6 @@ require 'blink/type/symlink'
require 'blink/type/package'
require 'blink/type/component'
require 'blink/statechange'
+require 'blink/type/typegen'
+require 'blink/type/typegen/filetype'
+require 'blink/type/typegen/filerecord'
diff --git a/lib/blink/type/component.rb b/lib/blink/type/component.rb
index 43906f749..91eff0390 100644
--- a/lib/blink/type/component.rb
+++ b/lib/blink/type/component.rb
@@ -29,6 +29,7 @@ module Blink
def push(*ary)
ary.each { |child|
unless child.is_a?(Blink::Element)
+ Blink.notice "Got object of type %s" % child.class
raise "Containers can only contain Blink::Elements"
end
@children.push child
diff --git a/lib/blink/type/typegen.rb b/lib/blink/type/typegen.rb
index 9643d8462..104e79aef 100644
--- a/lib/blink/type/typegen.rb
+++ b/lib/blink/type/typegen.rb
@@ -7,10 +7,12 @@
require 'etc'
require 'blink/type'
-class Blink::Type::TypeGenerator < Blink::Type
+module Blink
+ class Type
+class TypeGenerator < Blink::Type
include Enumerable
- @namevar = :notused
+ @namevar = :name
@name = :typegen
@abstract = true
@@ -22,13 +24,17 @@ class Blink::Type::TypeGenerator < Blink::Type
#---------------------------------------------------------------
def TypeGenerator.inherited(subclass)
- subclass.initvars
+ #subclass.initvars
+ super(subclass)
end
#---------------------------------------------------------------
#---------------------------------------------------------------
+ # we don't need to 'super' here because type.rb already runs initvars
+ # in Type#inherited
def TypeGenerator.initvars
@subclasses = Hash.new(nil)
+ super
end
#---------------------------------------------------------------
@@ -46,25 +52,42 @@ class Blink::Type::TypeGenerator < Blink::Type
#---------------------------------------------------------------
def TypeGenerator.namevar
- return :notused
+ return @namevar || :name
+ end
+ #---------------------------------------------------------------
+
+ #---------------------------------------------------------------
+ def TypeGenerator.namevar=(namevar)
+ Blink.debug "Setting namevar for %s to %s" % [self,namevar]
+ unless namevar.is_a? Symbol
+ namevar = namevar.intern
+ end
+ @namevar = namevar
end
#---------------------------------------------------------------
#---------------------------------------------------------------
def TypeGenerator.newtype(arghash)
- unless defined? @options
+ unless defined? @parameters
raise "Type %s is set up incorrectly" % self
end
arghash.each { |key,value|
- unless @options.include?(key)
+ if key.class != Symbol
+ # convert to a symbol
+ arghash[key.intern] = value
+ arghash.delete key
+ key = key.intern
+ end
+ unless @parameters.include?(key)
raise "Invalid argument %s on class %s" %
[key,self]
end
+
}
# turn off automatically checking all arguments
- #@options.each { |option|
+ #@parameters.each { |option|
# unless arghash.include?(option)
# p arghash
# raise "Must pass %s to class %s" %
@@ -100,7 +123,7 @@ class Blink::Type::TypeGenerator < Blink::Type
# i couldn't get the method definition stuff to work
# oh well
# probably wouldn't want it in the end anyway
- #@options.each { |option|
+ #@parameters.each { |option|
# writer = option.id2name + "="
# readproc = proc { eval("@" + option.id2name) }
# klass.send(:define_method,option,readproc)
@@ -109,8 +132,12 @@ class Blink::Type::TypeGenerator < Blink::Type
# klass.send(writer,hash[option])
#}
+ #Blink::Type.inherited(klass)
+ Blink::Type.buildtypehash
return klass
end
#---------------------------------------------------------------
end
#---------------------------------------------------------------
+end
+end
diff --git a/lib/blink/type/typegen/filerecord.rb b/lib/blink/type/typegen/filerecord.rb
index 8c7c042b5..fb9030c12 100644
--- a/lib/blink/type/typegen/filerecord.rb
+++ b/lib/blink/type/typegen/filerecord.rb
@@ -12,18 +12,24 @@ require 'blink/type/typegen'
class Blink::Type::FileRecord < Blink::Type::TypeGenerator
attr_accessor :fields, :namevar, :splitchar, :object
- @options = [:name, :splitchar, :fields, :namevar, :filetype, :regex, :joinchar]
+ @parameters = [:name, :splitchar, :fields, :namevar, :filetype, :regex, :joinchar]
@abstract = true
@metaclass = true
+ @namevar = :name
@name = :filerecord
#---------------------------------------------------------------
def FileRecord.newtype(hash)
- shortname = hash[:name]
- hash[:name] = hash[:filetype].name.capitalize + hash[:name].capitalize
+ #shortname = hash[:name]
+ #hash[:name] = hash[:filetype].name.capitalize + hash[:name].capitalize
klass = super(hash)
- klass.name = shortname
+ #klass.name = shortname
+ klass.parameters = hash[:fields]
+ #klass.namevar = hash[:namevar]
+ klass.filetype = hash[:filetype]
+ hash.delete(:fields)
+ hash.delete(:namevar)
return klass
end
#---------------------------------------------------------------
@@ -48,7 +54,13 @@ class Blink::Type::FileRecord < Blink::Type::TypeGenerator
#---------------------------------------------------------------
def FileRecord.filetype=(filetype)
- @filetype = filetype
+ if filetype.is_a?(String)
+ @filetype = Blink::Type::FileType[filetype]
+ elsif filetype.is_a?(Blink::Type::FileType)
+ @filetype = filetype
+ else
+ raise "Cannot use objects of type %s as filetypes" % filetype
+ end
end
#---------------------------------------------------------------
@@ -87,18 +99,6 @@ class Blink::Type::FileRecord < Blink::Type::TypeGenerator
#---------------------------------------------------------------
#---------------------------------------------------------------
- def FileRecord.namevar=(field)
- @namevar = field
- end
- #---------------------------------------------------------------
-
- #---------------------------------------------------------------
- def FileRecord.namevar
- return @namevar
- end
- #---------------------------------------------------------------
-
- #---------------------------------------------------------------
def FileRecord.regex=(regex)
@regex = regex
end
@@ -148,15 +148,15 @@ class Blink::Type::FileRecord < Blink::Type::TypeGenerator
#---------------------------------------------------------------
#---------------------------------------------------------------
- def [](field)
- @fields[field]
- end
+ #def [](field)
+ # @parameters[field]
+ #end
#---------------------------------------------------------------
#---------------------------------------------------------------
- def []=(field,value)
- @fields[field] = value
- end
+ #def []=(field,value)
+ # @parameters[field] = value
+ #end
#---------------------------------------------------------------
#---------------------------------------------------------------
@@ -168,7 +168,7 @@ class Blink::Type::FileRecord < Blink::Type::TypeGenerator
unless self.name == other.name
return false
end
- @fields.keys { |field|
+ @parameters.keys { |field|
unless self[field] == other[field]
Blink.debug("%s -> %s has changed" % [self.name, field])
return false
@@ -179,12 +179,16 @@ class Blink::Type::FileRecord < Blink::Type::TypeGenerator
#---------------------------------------------------------------
#---------------------------------------------------------------
- def initialize(object)
- @object = object
- @fields = {}
- if block_given?
- yield self
+ def initialize(hash)
+ if self.class == Blink::Type::FileRecord
+ self.class.newtype(hash)
+ return
end
+ @parameters = {}
+ #if block_given?
+ # yield self
+ #end
+ super(hash)
end
#---------------------------------------------------------------
@@ -193,8 +197,8 @@ class Blink::Type::FileRecord < Blink::Type::TypeGenerator
@match = matchobj
#puts "captures are [%s]" % [matchobj.captures]
self.class.fields.zip(matchobj.captures) { |field,value|
- @fields[field] = value
- #puts "%s => %s" % [field,@fields[field]]
+ @parameters[field] = value
+ #puts "%s => %s" % [field,@parameters[field]]
}
end
#---------------------------------------------------------------
@@ -207,18 +211,19 @@ class Blink::Type::FileRecord < Blink::Type::TypeGenerator
raise RegexpError.new(detail)
end
self.class.fields.each { |field|
- @fields[field] = ary.shift
- #puts "%s => %s" % [field,@fields[field]]
+ @parameters[field] = ary.shift
+ #puts "%s => %s" % [field,@parameters[field]]
}
end
#---------------------------------------------------------------
#---------------------------------------------------------------
def name
- if @fields.include?(self.class.namevar)
- return @fields[self.class.namevar]
+ if @parameters.include?(self.class.namevar)
+ return @parameters[self.class.namevar]
else
- raise "No namevar for objects of type %s" % self.class.to_s
+ raise "No namevar '%s' for objects of type %s" %
+ [self.class.namevar,self.class.to_s]
end
end
#---------------------------------------------------------------
@@ -226,10 +231,10 @@ class Blink::Type::FileRecord < Blink::Type::TypeGenerator
#---------------------------------------------------------------
def to_s
ary = self.class.fields.collect { |field|
- if ! @fields.include?(field)
+ if ! @parameters.include?(field)
raise "Object %s is missing field %s" % [self.name,field]
else
- @fields[field]
+ @parameters[field]
end
}.join(self.class.joinchar || self.class.splitchar)
end
diff --git a/lib/blink/type/typegen/filetype.rb b/lib/blink/type/typegen/filetype.rb
index 44cb76826..4b3b89db8 100644
--- a/lib/blink/type/typegen/filetype.rb
+++ b/lib/blink/type/typegen/filetype.rb
@@ -10,10 +10,11 @@ require 'blink/type/typegen'
class Blink::Type::FileType < Blink::Type::TypeGenerator
attr_accessor :childtype
- @options = [:name, :linesplit, :escapednewlines]
- @abstract = true
+ @parameters = [:name, :linesplit, :escapednewlines]
+ #@abstract = true
@metaclass = true
+ @namevar = :name
@name = :filetype
@modsystem = true
@@ -23,9 +24,14 @@ class Blink::Type::FileType < Blink::Type::TypeGenerator
unless hash.include?(:linesplit)
hash[:linesplit] = "\n"
end
+
+ # i don't think there's any reason to 'super' this
+ #klass = Blink::Type::TypeGenerator.newtype(hash)
klass = super(hash)
klass.escapednewlines = true
+ klass.namevar = :name
+ klass.parameters = [:name, :path, :complete]
#klass.childtype = Blink::Type::FileRecord.newtype(
# :name => hash[:name] + "_record",
@@ -119,14 +125,14 @@ class Blink::Type::FileType < Blink::Type::TypeGenerator
#---------------------------------------------------------------
#---------------------------------------------------------------
- def [](name)
- return @childhash[name]
- end
+ #def [](name)
+ # return @childhash[name]
+ #end
#---------------------------------------------------------------
#---------------------------------------------------------------
- def []=(name,value)
- end
+ #def []=(name,value)
+ #end
#---------------------------------------------------------------
#---------------------------------------------------------------
@@ -194,11 +200,22 @@ class Blink::Type::FileType < Blink::Type::TypeGenerator
#---------------------------------------------------------------
# create a new file
- def initialize(file)
- @file = file
+ def initialize(hash)
+ # if we are the FileType object itself, we create a new type
+ # otherwise, we create an instance of an existing type
+ # yes, this should be more straightforward
+ if self.class == Blink::Type::FileType
+ self.class.newtype(hash)
+ return
+ end
+ Blink.debug "Creating new '%s' file with path '%s' and name '%s'" %
+ [self.class.name,hash["path"],hash[:name]]
+ Blink.debug hash.inspect
+ @file = hash["path"]
@childary = []
@childhash = {}
+ super
end
#---------------------------------------------------------------
@@ -216,9 +233,9 @@ class Blink::Type::FileType < Blink::Type::TypeGenerator
#---------------------------------------------------------------
#---------------------------------------------------------------
- def name
- return @file
- end
+ #def name
+ # return @file
+ #end
#---------------------------------------------------------------
#---------------------------------------------------------------
generated by cgit (git 2.34.1) at 2025-10-04 06:33:33 +0000